home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Term / Extras / Source / term-source.lha / PhonePanel.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  66KB  |  2,826 lines
  1. /*
  2. **    PhonePanel.c
  3. **
  4. **    The phonebook and support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16.     /* The gadget IDs are in there */
  17.  
  18. #ifndef _PHONEPANEL_H
  19. #include "PhonePanel.h"
  20. #endif    /* _PHONEPANEL_H */
  21.  
  22.     /* What action is to follow clicking into the listview. */
  23.  
  24. enum    {    CLICK_Select,CLICK_Toggle };
  25.  
  26.     /* What to do with an entry. */
  27.  
  28. enum    {    CHANGE_Set,CHANGE_Clear,CHANGE_Toggle };
  29.  
  30.     /* Local prototypes. */
  31.  
  32. STATIC VOID CloseSomeWindow(PhoneListContext *Context, struct Window *Window);
  33. STATIC VOID LockInterface(PhoneListContext *Context);
  34. STATIC VOID UnlockInterface(PhoneListContext *Context);
  35. STATIC VOID HighlightActiveEntry(PhoneListContext *Context, BOOL Activate);
  36. STATIC VOID UpdateWindowTitle(PhoneListContext *Context);
  37. STATIC VOID UpdateEditorData(PhoneListContext *Context);
  38. STATIC PhoneGroupNode *GetActiveGroup(PhoneListContext *Context);
  39. STATIC VOID DeletePhoneListContext(PhoneListContext *Context);
  40. STATIC PhoneListContext *CreatePhoneListContext(PhonebookHandle *PhoneHandle);
  41. STATIC VOID SelectActiveEntry(PhoneListContext *Context, LONG Index, BOOL ShowIt);
  42. STATIC VOID DetachList(PhoneListContext *Context);
  43. STATIC VOID AttachList(PhoneListContext *Context);
  44. STATIC VOID UpdateActiveEntry(PhoneListContext *Context);
  45. STATIC VOID ChangeActiveEntry(PhoneListContext *Context, LONG How);
  46. STATIC VOID ToggleAllEntries(PhoneListContext *Context);
  47. STATIC VOID SelectAllEntries(PhoneListContext *Context);
  48. STATIC VOID ClearAllEntries(PhoneListContext *Context);
  49. STATIC VOID SelectIfMarked(PhoneListContext *Context);
  50. STATIC VOID DeleteActiveEntry(PhoneListContext *Context);
  51. STATIC VOID CopyActiveEntry(PhoneListContext *Context);
  52. STATIC VOID LoadNewPhonebook(PhoneListContext *Context);
  53. STATIC VOID MergeNewPhonebook(PhoneListContext *Context);
  54. STATIC VOID ChangeGroup(PhoneListContext *Context);
  55. STATIC VOID SelectGroup(PhoneListContext *Context, LONG Index);
  56. STATIC VOID SplitGroup(PhoneListContext *Context);
  57. STATIC VOID SortThePhonebook(PhoneListContext *Context, LONG How, BOOL ReverseOrder);
  58. STATIC VOID SelectNewTaggedEntry(PhoneListContext *Context, LONG How);
  59. STATIC VOID MoveActiveEntry(PhoneListContext *Context, LONG How);
  60. STATIC VOID AddNewEntry(PhoneListContext *Context);
  61.  
  62. /******************************************************************************/
  63.  
  64. STATIC VOID
  65. CloseSomeWindow(PhoneListContext *Context,struct Window *Window)
  66. {
  67.     struct Window **WindowPtr;
  68.     LayoutHandle **HandlePtr;
  69.  
  70.     WindowPtr = NULL;
  71.     HandlePtr = NULL;
  72.  
  73.     if(Window == Context->Window)
  74.     {
  75.         WindowPtr = &Context->Window;
  76.         HandlePtr = &Context->Manager;
  77.     }
  78.  
  79.     if(Window == Context->EditWindow)
  80.     {
  81.         WindowPtr = &Context->EditWindow;
  82.         HandlePtr = &Context->Editor;
  83.     }
  84.  
  85.     if(Window == Context->PatternWindow)
  86.     {
  87.         WindowPtr = &Context->PatternWindow;
  88.         HandlePtr = &Context->Selector;
  89.     }
  90.  
  91.     if(Window == Context->GroupWindow)
  92.     {
  93.         WindowPtr = &Context->GroupWindow;
  94.         HandlePtr = &Context->Grouping;
  95.     }
  96.  
  97.     if(Window == Context->SortWindow)
  98.     {
  99.         WindowPtr = &Context->SortWindow;
  100.         HandlePtr = &Context->Sorting;
  101.     }
  102.  
  103.     if(Window == Context->PasswordWindow)
  104.     {
  105.         WindowPtr = &Context->PasswordWindow;
  106.         HandlePtr = &Context->PasswordHandle;
  107.     }
  108.  
  109.     if(WindowPtr)
  110.     {
  111.         LT_DeleteHandle(*HandlePtr);
  112.  
  113.         if(Window != Context->Window)
  114.             LT_ShowWindow(Context->Manager,TRUE);
  115.  
  116.         *HandlePtr = NULL;
  117.         *WindowPtr = NULL;
  118.     }
  119. }
  120.  
  121. STATIC VOID
  122. LockInterface(PhoneListContext *Context)
  123. {
  124.     LT_LockWindow(Context->Window);
  125.     LT_LockWindow(Context->PasswordWindow);
  126.     LT_LockWindow(Context->EditWindow);
  127.     LT_LockWindow(Context->PatternWindow);
  128.     LT_LockWindow(Context->GroupWindow);
  129.     LT_LockWindow(Context->SortWindow);
  130. }
  131.  
  132. STATIC VOID
  133. UnlockInterface(PhoneListContext *Context)
  134. {
  135.     LT_UnlockWindow(Context->Window);
  136.     LT_UnlockWindow(Context->PasswordWindow);
  137.     LT_UnlockWindow(Context->EditWindow);
  138.     LT_UnlockWindow(Context->PatternWindow);
  139.     LT_UnlockWindow(Context->GroupWindow);
  140.     LT_UnlockWindow(Context->SortWindow);
  141. }
  142.  
  143. STATIC VOID
  144. HighlightActiveEntry(PhoneListContext *Context,BOOL Activate)
  145. {
  146.     BOOL IsFirst,IsLast,Disabled;
  147.     LayoutHandle *Manager;
  148.     LayoutHandle *Editor;
  149.     struct List *PhoneList;
  150.     PhoneNode *Node;
  151.     ULONG Count;
  152.     ULONG Grouper;
  153.     BOOL Hide;
  154.  
  155.     Manager = Context->Manager;
  156.     Editor = Context->Editor;
  157.     PhoneList = Context->CurrentList;
  158.     Count = Context->PhoneHandle->DialMarker;
  159.     Grouper = Context->PhoneHandle->DefaultGroup;
  160.     Hide = Context->Hide;
  161.     Node = Context->SelectedNode;
  162.  
  163.     if(Node)
  164.     {
  165.         IsFirst        = (Node == (struct PhoneNode *)PhoneList->lh_Head);
  166.         IsLast        = (Node == (struct PhoneNode *)PhoneList->lh_TailPred);
  167.         Disabled    = FALSE;
  168.     }
  169.     else
  170.     {
  171.         IsFirst        = TRUE;
  172.         IsLast        = TRUE;
  173.         Disabled    = TRUE;
  174.     }
  175.  
  176.     LT_SetAttributes(Manager,GAD_COMMENTLINE,
  177.         LABX_Text,        Node ? Node->Entry->Header->Comment : (STRPTR)"",
  178.     TAG_DONE);
  179.  
  180.     LT_SetAttributes(Manager,GAD_MOVE_FIRST,
  181.         GA_Disabled,    IsFirst || Disabled,
  182.     TAG_DONE);
  183.  
  184.     LT_SetAttributes(Manager,GAD_MOVE_UP,
  185.         GA_Disabled,    IsFirst || Disabled,
  186.     TAG_DONE);
  187.  
  188.     LT_SetAttributes(Manager,GAD_MOVE_DOWN,
  189.         GA_Disabled,    IsLast || Disabled,
  190.     TAG_DONE);
  191.  
  192.     LT_SetAttributes(Manager,GAD_MOVE_LAST,
  193.         GA_Disabled,    IsLast || Disabled,
  194.     TAG_DONE);
  195.  
  196.     LT_SetAttributes(Manager,GAD_EDIT,
  197.         GA_Disabled,    !Node || Disabled,
  198.     TAG_DONE);
  199.  
  200.     LT_SetAttributes(Manager,GAD_COPY,
  201.         GA_Disabled,    !Node || Disabled,
  202.     TAG_DONE);
  203.  
  204.     LT_SetAttributes(Manager,GAD_DELETE,
  205.         GA_Disabled,    !Node || Disabled || Node->Entry == GetActiveEntry(Context->PhoneHandle),
  206.     TAG_DONE);
  207.  
  208.     LT_SetAttributes(Manager,GAD_USE,
  209.         GA_Disabled,    !Node || Disabled,
  210.     TAG_DONE);
  211.  
  212.     LT_SetAttributes(Manager,GAD_MAKE_GROUP,
  213.         GA_Disabled,    !Node && !Count,
  214.     TAG_DONE);
  215.  
  216.     LT_SetAttributes(Manager,GAD_SPLIT_GROUP,
  217.         GA_Disabled,    Grouper == 0,
  218.     TAG_DONE);
  219.  
  220.     LT_SetAttributes(Manager,GAD_SELECT,
  221.         GA_Disabled,    Disabled || (Node && Node->Entry->Count != -1),
  222.     TAG_DONE);
  223.  
  224.     LT_SetAttributes(Manager,GAD_CLEAR,
  225.         GA_Disabled,    Disabled || (Node && Node->Entry->Count == -1),
  226.     TAG_DONE);
  227.  
  228.     LT_SetAttributes(Manager,GAD_TOGGLE_ALL,
  229.         GA_Disabled,    Context->NumEntries == 0,
  230.     TAG_DONE);
  231.  
  232.     LT_SetAttributes(Manager,GAD_SELECT_ALL,
  233.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries || Count == Context->PhoneHandle->NumPhoneEntries,
  234.     TAG_DONE);
  235.  
  236.     LT_SetAttributes(Manager,GAD_CLEAR_ALL,
  237.         GA_Disabled,    !Count,
  238.     TAG_DONE);
  239.  
  240.     LT_SetAttributes(Manager,GAD_PATTERN,
  241.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  242.     TAG_DONE);
  243.  
  244.     LT_SetAttributes(Manager,GAD_DIAL,
  245.         GA_Disabled,    (Online && !Config->MiscConfig->ProtectiveMode) || (!Node && Context->PhoneHandle->DialMarker == 0) || (Node && Context->PhoneHandle->DialMarker == 0 && !(Node->Entry->Header->Number[0] || Node->Entry->Header->Name[0])),
  246.     TAG_DONE);
  247.  
  248.     LT_SetAttributes(Manager,GAD_LOAD,
  249.         GA_Disabled,    GetActiveEntry(Context->PhoneHandle) != NULL,
  250.     TAG_DONE);
  251.  
  252.     LT_SetAttributes(Manager,GAD_MERGE,
  253.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  254.     TAG_DONE);
  255.  
  256.     LT_SetAttributes(Manager,GAD_SAVE,
  257.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  258.     TAG_DONE);
  259.  
  260.     LT_SetAttributes(Manager,GAD_PRINT,
  261.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  262.     TAG_DONE);
  263.  
  264.     LT_SetAttributes(Manager,GAD_SORT,
  265.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  266.     TAG_DONE);
  267.  
  268.     LT_SetAttributes(Manager,GAD_COPY_CONFIG,
  269.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  270.     TAG_DONE);
  271.  
  272.     LT_SetAttributes(Manager,GAD_SORT_ORDER,
  273.         GA_Disabled,    !Context->PhoneHandle->NumPhoneEntries,
  274.     TAG_DONE);
  275.  
  276.     LT_SetAttributes(Manager,GAD_GROUPID,
  277.         GTCY_Active,    Grouper,
  278.     TAG_DONE);
  279.  
  280.     if(Editor)
  281.     {
  282.         struct Configuration *LocalConfig;
  283.         BOOL RatesValid;
  284.  
  285.         if(Node)
  286.         {
  287.             IsFirst            = (Node->Entry->Count == -1) || (Node->Entry->Count == 0);
  288.             IsLast            = (Node->Entry->Count == -1) || (Node->Entry->Count == Count - 1);
  289.             Disabled        = FALSE;
  290.             LocalConfig        = Node->Entry->Config;
  291.             RatesValid        = (!IsListEmpty((struct List *)&Node->Entry->TimeDateList) && !Node->Entry->Header->NoRates);
  292.         }
  293.         else
  294.         {
  295.             IsFirst            = TRUE;
  296.             IsLast            = TRUE;
  297.             Disabled        = TRUE;
  298.             LocalConfig        = NULL;
  299.             RatesValid        = FALSE;
  300.         }
  301.  
  302.         LT_SetAttributes(Editor,GAD_SYSTEM_NAME,
  303.             GTST_String,    Node ? Node->Entry->Header->Name : (STRPTR)"",
  304.             GA_Disabled,    Disabled,
  305.         TAG_DONE);
  306.  
  307.         LT_SetAttributes(Editor,GAD_COMMENT,
  308.             GTST_String,    Node ? Node->Entry->Header->Comment : (STRPTR)"",
  309.             GA_Disabled,    Disabled,
  310.         TAG_DONE);
  311.  
  312.         LT_SetAttributes(Editor,GAD_NUMBERS,
  313.             GTST_String,    Node ? Node->Entry->Header->Number : (STRPTR)"",
  314.             GA_Disabled,    Disabled,
  315.         TAG_DONE);
  316.  
  317.         LT_SetAttributes(Editor,GAD_QUICK_MENU,
  318.             GTCB_Checked,    Node ? Node->Entry->Header->QuickMenu : FALSE,
  319.             GA_Disabled,    Disabled,
  320.         TAG_DONE);
  321.  
  322.         LT_SetAttributes(Editor,GAD_AUTODIAL,
  323.             GTCB_Checked,    Node ? Node->Entry->Header->AutoDial : FALSE,
  324.             GA_Disabled,    Disabled,
  325.         TAG_DONE);
  326.  
  327.         LT_SetAttributes(Editor,GAD_USER_NAME,
  328.             GTST_String,    (Node && !Hide) ? Node->Entry->Header->UserName : (STRPTR)"",
  329.             GA_Disabled,    Hide || Disabled,
  330.         TAG_DONE);
  331.  
  332.         LT_SetAttributes(Editor,GAD_USER_PASSWORD,
  333.             GTST_String,    (Node && !Hide) ? Node->Entry->Header->Password : (STRPTR)"",
  334.             GA_Disabled,    Hide || Disabled,
  335.         TAG_DONE);
  336.  
  337.  
  338.         LT_SetAttributes(Editor,GAD_SERIAL_STATE,
  339.             GTCB_Checked,    LocalConfig ? (LocalConfig->SerialConfig != NULL) : FALSE,
  340.             GA_Disabled,    Disabled,
  341.         TAG_DONE);
  342.  
  343.         LT_SetAttributes(Editor,GAD_SERIAL_EDIT,
  344.             GA_Disabled,    Disabled,
  345.         TAG_DONE);
  346.  
  347.         LT_SetAttributes(Editor,GAD_MODEM_STATE,
  348.             GTCB_Checked,    LocalConfig ? (LocalConfig->ModemConfig != NULL) : FALSE,
  349.             GA_Disabled,    Disabled,
  350.         TAG_DONE);
  351.  
  352.         LT_SetAttributes(Editor,GAD_MODEM_EDIT,
  353.             GA_Disabled,    Disabled,
  354.         TAG_DONE);
  355.  
  356.         LT_SetAttributes(Editor,GAD_SCREEN_STATE,
  357.             GTCB_Checked,    LocalConfig ? (LocalConfig->ScreenConfig != NULL) : FALSE,
  358.             GA_Disabled,    Disabled,
  359.         TAG_DONE);
  360.  
  361.         LT_SetAttributes(Editor,GAD_SCREEN_EDIT,
  362.             GA_Disabled,    Disabled,
  363.         TAG_DONE);
  364.  
  365.         LT_SetAttributes(Editor,GAD_TERMINAL_STATE,
  366.             GTCB_Checked,    LocalConfig ? (LocalConfig->TerminalConfig != NULL) : FALSE,
  367.             GA_Disabled,    Disabled,
  368.         TAG_DONE);
  369.  
  370.         LT_SetAttributes(Editor,GAD_TERMINAL_EDIT,
  371.             GA_Disabled,    Disabled,
  372.         TAG_DONE);
  373.  
  374.         LT_SetAttributes(Editor,GAD_EMULATION_STATE,
  375.             GTCB_Checked,    LocalConfig ? (LocalConfig->EmulationConfig != NULL) : FALSE,
  376.             GA_Disabled,    Disabled,
  377.         TAG_DONE);
  378.  
  379.         LT_SetAttributes(Editor,GAD_EMULATION_EDIT,
  380.             GA_Disabled,    Disabled,
  381.         TAG_DONE);
  382.  
  383.         LT_SetAttributes(Editor,GAD_CLIPBOARD_STATE,
  384.             GTCB_Checked,    LocalConfig ? (LocalConfig->ClipConfig != NULL) : FALSE,
  385.             GA_Disabled,    Disabled,
  386.         TAG_DONE);
  387.  
  388.         LT_SetAttributes(Editor,GAD_CLIPBOARD_EDIT,
  389.             GA_Disabled,    Disabled,
  390.         TAG_DONE);
  391.  
  392.         LT_SetAttributes(Editor,GAD_CAPTURE_STATE,
  393.             GTCB_Checked,    LocalConfig ? (LocalConfig->CaptureConfig != NULL) : FALSE,
  394.             GA_Disabled,    Disabled,
  395.         TAG_DONE);
  396.  
  397.         LT_SetAttributes(Editor,GAD_CAPTURE_EDIT,
  398.             GA_Disabled,    Disabled,
  399.         TAG_DONE);
  400.  
  401.         LT_SetAttributes(Editor,GAD_COMMAND_STATE,
  402.             GTCB_Checked,    LocalConfig ? (LocalConfig->CommandConfig != NULL) : FALSE,
  403.             GA_Disabled,    Disabled,
  404.         TAG_DONE);
  405.  
  406.         LT_SetAttributes(Editor,GAD_COMMAND_EDIT,
  407.             GA_Disabled,    Disabled,
  408.         TAG_DONE);
  409.  
  410.         LT_SetAttributes(Editor,GAD_MISC_STATE,
  411.             GTCB_Checked,    LocalConfig ? (LocalConfig->MiscConfig != NULL) : FALSE,
  412.             GA_Disabled,    Disabled,
  413.         TAG_DONE);
  414.  
  415.         LT_SetAttributes(Editor,GAD_MISC_EDIT,
  416.             GA_Disabled,    Disabled,
  417.         TAG_DONE);
  418.  
  419.         LT_SetAttributes(Editor,GAD_PATH_STATE,
  420.             GTCB_Checked,    LocalConfig ? (LocalConfig->PathConfig != NULL) : FALSE,
  421.             GA_Disabled,    Disabled,
  422.         TAG_DONE);
  423.  
  424.         LT_SetAttributes(Editor,GAD_PATH_EDIT,
  425.             GA_Disabled,    Disabled,
  426.         TAG_DONE);
  427.  
  428.         LT_SetAttributes(Editor,GAD_TRANSFER_STATE,
  429.             GTCB_Checked,    LocalConfig ? (LocalConfig->TransferConfig != NULL) : FALSE,
  430.             GA_Disabled,    Disabled,
  431.         TAG_DONE);
  432.  
  433.         LT_SetAttributes(Editor,GAD_TRANSFER_EDIT,
  434.             GA_Disabled,    Disabled,
  435.         TAG_DONE);
  436.  
  437.         LT_SetAttributes(Editor,GAD_TRANSLATION_STATE,
  438.             GTCB_Checked,    LocalConfig ? (LocalConfig->TranslationFileName != NULL) : FALSE,
  439.             GA_Disabled,    Disabled,
  440.         TAG_DONE);
  441.  
  442.         LT_SetAttributes(Editor,GAD_TRANSLATION_EDIT,
  443.             GA_Disabled,    Disabled,
  444.         TAG_DONE);
  445.  
  446.         LT_SetAttributes(Editor,GAD_MACRO_STATE,
  447.             GTCB_Checked,    LocalConfig ? (LocalConfig->MacroFileName != NULL) : FALSE,
  448.             GA_Disabled,    Disabled,
  449.         TAG_DONE);
  450.  
  451.         LT_SetAttributes(Editor,GAD_MACRO_EDIT,
  452.             GA_Disabled,    Disabled,
  453.         TAG_DONE);
  454.  
  455.         LT_SetAttributes(Editor,GAD_CURSOR_STATE,
  456.             GTCB_Checked,    LocalConfig ? (LocalConfig->CursorFileName != NULL) : FALSE,
  457.             GA_Disabled,    Disabled,
  458.         TAG_DONE);
  459.  
  460.         LT_SetAttributes(Editor,GAD_CURSOR_EDIT,
  461.             GA_Disabled,    Disabled,
  462.         TAG_DONE);
  463.  
  464.         LT_SetAttributes(Editor,GAD_FASTMACRO_STATE,
  465.             GTCB_Checked,    LocalConfig ? (LocalConfig->FastMacroFileName != NULL) : FALSE,
  466.             GA_Disabled,    Disabled,
  467.         TAG_DONE);
  468.  
  469.         LT_SetAttributes(Editor,GAD_FASTMACRO_EDIT,
  470.             GA_Disabled,    Disabled,
  471.         TAG_DONE);
  472.  
  473.         LT_SetAttributes(Editor,GAD_RATE_STATE,
  474.             GTCB_Checked,    RatesValid,
  475.             GA_Disabled,    Disabled,
  476.         TAG_DONE);
  477.  
  478.         LT_SetAttributes(Editor,GAD_RATE_EDIT,
  479.             GA_Disabled,    Disabled,
  480.         TAG_DONE);
  481.  
  482.         LT_SetAttributes(Editor,GAD_FIRST_ENTRY,
  483.             GA_Disabled,    Disabled || IsFirst,
  484.         TAG_DONE);
  485.  
  486.         LT_SetAttributes(Editor,GAD_PREVIOUS_ENTRY,
  487.             GA_Disabled,    Disabled || IsFirst,
  488.         TAG_DONE);
  489.  
  490.         LT_SetAttributes(Editor,GAD_NEXT_ENTRY,
  491.             GA_Disabled,    Disabled || IsLast,
  492.         TAG_DONE);
  493.  
  494.         LT_SetAttributes(Editor,GAD_LAST_ENTRY,
  495.             GA_Disabled,    Disabled || IsLast,
  496.         TAG_DONE);
  497.  
  498.         if(Activate)
  499.         {
  500.             LT_ShowWindow(Editor,TRUE);
  501.  
  502.             LT_Activate(Editor,GAD_SYSTEM_NAME);
  503.         }
  504.     }
  505. }
  506.  
  507. STATIC VOID
  508. UpdateWindowTitle(PhoneListContext *Context)
  509. {
  510.     STRPTR Title;
  511.  
  512.     if(Context->PhoneHandle->DialMarker > 0)
  513.         LimitedSPrintf(sizeof(Context->WindowTitle),Title = Context->WindowTitle,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Context->PhoneHandle->DialMarker,Context->PhoneHandle->NumPhoneEntries);
  514.     else
  515.         Title = LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT);
  516.  
  517.     SetWindowTitles(Context->Window,Title,(STRPTR)~0);
  518. }
  519.  
  520. STATIC VOID
  521. UpdateEditorData(PhoneListContext *Context)
  522. {
  523.     if(Context->Editor && Context->SelectedNode)
  524.     {
  525.         PhoneHeader        *Header    = Context->SelectedNode->Entry->Header;
  526.         LayoutHandle    *Editor    = Context->Editor;
  527.  
  528.         strcpy(Header->Name,    LT_GetString(Editor,GAD_SYSTEM_NAME));
  529.         strcpy(Header->Comment,    LT_GetString(Editor,GAD_COMMENT));
  530.         strcpy(Header->Number,    LT_GetString(Editor,GAD_NUMBERS));
  531.  
  532.         if(!Context->Hide)
  533.         {
  534.             strcpy(Header->UserName,LT_GetString(Editor,GAD_USER_NAME));
  535.             strcpy(Header->Password,LT_GetString(Editor,GAD_USER_PASSWORD));
  536.         }
  537.  
  538.         UpdatePhoneNode(Context->SelectedNode);
  539.         UpdateActiveEntry(Context);
  540.     }
  541. }
  542.  
  543. STATIC PhoneGroupNode *
  544. GetActiveGroup(PhoneListContext *Context)
  545. {
  546.     if(Context->PhoneHandle->DefaultGroup > 0)
  547.     {
  548.         STRPTR Name;
  549.  
  550.         Name = Context->GroupLabels[Context->PhoneHandle->DefaultGroup];
  551.  
  552.         return((PhoneGroupNode *)((ULONG)Name - offsetof(PhoneGroupNode,LocalName)));
  553.     }
  554.     else
  555.         return(NULL);
  556. }
  557.  
  558. STATIC VOID
  559. DeletePhoneListContext(PhoneListContext *Context)
  560. {
  561.     DeletePhoneList(Context->PhoneHandle);
  562.     FreeVecPooled(Context->GroupLabels);
  563.     DeleteMsgPort(Context->WindowPort);
  564.     FreeVecPooled(Context);
  565. }
  566.  
  567. STATIC PhoneListContext *
  568. CreatePhoneListContext(PhonebookHandle *PhoneHandle)
  569. {
  570.     PhoneListContext *Context;
  571.  
  572.     if(Context = (PhoneListContext *)AllocVecPooled(sizeof(*Context),MEMF_ANY|MEMF_CLEAR))
  573.     {
  574.             /* Create the message port */
  575.  
  576.         if(Context->WindowPort = CreateMsgPort())
  577.         {
  578.                 /* Create the group labels */
  579.  
  580.             if(Context->GroupLabels = BuildLabels(PhoneHandle))
  581.             {
  582.                 LONG i;
  583.  
  584.                     /* Count the number of labels */
  585.  
  586.                 for(i = 0 ; Context->GroupLabels[i] != NULL ; i++);
  587.  
  588.                     /* If the group index is larger than the group label table */
  589.                     /* permits, truncate it. */
  590.  
  591.                 if(PhoneHandle->DefaultGroup >= i)
  592.                     PhoneHandle->DefaultGroup = i - 1;
  593.  
  594.                 Context->PhoneHandle    = PhoneHandle;
  595.                 Context->SelectedIndex    = -1;
  596.                 Context->Hide            = TRUE;
  597.  
  598.                     /* Preset the window title */
  599.  
  600.                 strcpy(Context->WindowTitle,LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT));
  601.  
  602.                 if(InitPhoneList(PhoneHandle))
  603.                 {
  604.                         /* Update the window title */
  605.  
  606.                     if(Context->PhoneHandle->DialMarker > 0)
  607.                         LimitedSPrintf(sizeof(Context->WindowTitle),Context->WindowTitle,LocaleString(MSG_PHONEPANEL_SELECTED_OUT_OF_TXT),LocaleString(MSG_PHONEPANEL_PHONEBOOK_TXT),Context->PhoneHandle->DialMarker,Context->PhoneHandle->NumPhoneEntries);
  608.  
  609.                         /* Are we to display a group list? */
  610.  
  611.                     if(PhoneHandle->DefaultGroup > 0)
  612.                     {
  613.                         PhoneGroupNode *GroupNode;
  614.  
  615.                         GroupNode = GetActiveGroup(Context);
  616.  
  617.                         Context->CurrentList    = (struct List *)&GroupNode->GroupList;
  618.                         Context->NumEntries        = GetListSize(Context->CurrentList);
  619.                     }
  620.                     else
  621.                     {
  622.                         Context->CurrentList    = PhoneHandle->PhoneList;
  623.                         Context->NumEntries        = PhoneHandle->NumPhoneEntries;
  624.                     }
  625.  
  626.                     return(Context);
  627.                 }
  628.  
  629.                 FreeVecPooled(Context->GroupLabels);
  630.             }
  631.  
  632.             DeleteMsgPort(Context->WindowPort);
  633.         }
  634.  
  635.         FreeVecPooled(Context);
  636.     }
  637.  
  638.     return(NULL);
  639. }
  640.  
  641. STATIC VOID
  642. SelectActiveEntry(PhoneListContext *Context,LONG Index,BOOL ShowIt)
  643. {
  644.     PhoneNode *Node;
  645.  
  646.     if(Context->PhoneHandle->DefaultGroup > 0)
  647.         Node = (PhoneNode *)GetListNode(Index,Context->CurrentList);
  648.     else
  649.     {
  650.         if(Index >= 0 && Index < Context->PhoneHandle->NumPhoneEntries)
  651.             Node = Context->PhoneHandle->Phonebook[Index]->Node;
  652.         else
  653.             Node = NULL;
  654.     }
  655.  
  656.     if(Node)
  657.     {
  658.         Context->SelectedNode    = Node;
  659.         Context->SelectedIndex    = Index;
  660.  
  661.         if(ShowIt)
  662.         {
  663.             LT_SetAttributes(Context->Manager,GAD_NAMELIST,
  664.                 LALV_Selected,Context->SelectedIndex,
  665.             TAG_DONE);
  666.         }
  667.  
  668.         HighlightActiveEntry(Context,FALSE);
  669.     }
  670. }
  671.  
  672. STATIC VOID
  673. DetachList(PhoneListContext *Context)
  674. {
  675.     LT_SetAttributes(Context->Manager,GAD_NAMELIST,
  676.         GTLV_Labels,~0,
  677.     TAG_DONE);
  678. }
  679.  
  680. STATIC VOID
  681. AttachList(PhoneListContext *Context)
  682. {
  683.     LT_SetAttributes(Context->Manager,GAD_NAMELIST,
  684.         GTLV_Labels,    Context->CurrentList,
  685.         GTLV_Selected,    Context->SelectedIndex,
  686.         GA_Disabled,    IsListEmpty(Context->CurrentList),
  687.     TAG_DONE);
  688. }
  689.  
  690. STATIC VOID
  691. UpdateActiveEntry(PhoneListContext *Context)
  692. {
  693.     if(Context->SelectedNode)
  694.     {
  695.         if(!Context->SelectedNode->Entry->Header->Name[0] || !Context->SelectedNode->Entry->Header->Number[0])
  696.             UnmarkDialEntry(Context->PhoneHandle,Context->SelectedNode->Entry);
  697.  
  698.         AttachList(Context);
  699.  
  700.         HighlightActiveEntry(Context,FALSE);
  701.     }
  702. }
  703.  
  704. STATIC VOID
  705. ChangeActiveEntry(PhoneListContext *Context,LONG How)
  706. {
  707.     if(Context->SelectedNode)
  708.     {
  709.         VOID (*Work)(PhonebookHandle *,PhoneEntry *);
  710.  
  711.         DetachList(Context);
  712.  
  713.         switch(How)
  714.         {
  715.             case CHANGE_Set:
  716.  
  717.                 Work = MarkDialEntry;
  718.                 break;
  719.  
  720.             case CHANGE_Clear:
  721.  
  722.                 Work = UnmarkDialEntry;
  723.                 break;
  724.  
  725.             case CHANGE_Toggle:
  726.  
  727.                 Work = ToggleDialEntry;
  728.                 break;
  729.         }
  730.  
  731.         (*Work)(Context->PhoneHandle,Context->SelectedNode->Entry);
  732.  
  733.         UpdateWindowTitle(Context);
  734.  
  735.         AttachList(Context);
  736.  
  737.         HighlightActiveEntry(Context,FALSE);
  738.     }
  739. }
  740.  
  741. STATIC VOID
  742. ToggleAllEntries(PhoneListContext *Context)
  743. {
  744.     PhoneNode *Node;
  745.  
  746.     DetachList(Context);
  747.  
  748.     for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  749.         ToggleDialEntry(Context->PhoneHandle,Node->Entry);
  750.  
  751.     UpdateWindowTitle(Context);
  752.  
  753.     AttachList(Context);
  754.  
  755.     HighlightActiveEntry(Context,FALSE);
  756. }
  757.  
  758. STATIC VOID
  759. SelectAllEntries(PhoneListContext *Context)
  760. {
  761.     PhoneNode *Node;
  762.  
  763.     DetachList(Context);
  764.  
  765.     for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  766.         MarkDialEntry(Context->PhoneHandle,Node->Entry);
  767.  
  768.     UpdateWindowTitle(Context);
  769.  
  770.     AttachList(Context);
  771.  
  772.     HighlightActiveEntry(Context,FALSE);
  773. }
  774.  
  775. STATIC VOID
  776. ClearAllEntries(PhoneListContext *Context)
  777. {
  778.     PhoneNode *Node;
  779.  
  780.     DetachList(Context);
  781.  
  782.     for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  783.         UnmarkDialEntry(Context->PhoneHandle,Node->Entry);
  784.  
  785.     UpdateWindowTitle(Context);
  786.  
  787.     AttachList(Context);
  788.  
  789.     Context->SelectedIndex    = -1;
  790.     Context->SelectedNode    = NULL;
  791.  
  792.     HighlightActiveEntry(Context,FALSE);
  793. }
  794.  
  795. STATIC VOID
  796. SelectIfMarked(PhoneListContext *Context)
  797. {
  798.     LONG HowManyMarked;
  799.     PhoneNode *Node;
  800.  
  801.     HowManyMarked = 0;
  802.  
  803.     for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  804.     {
  805.         if(Node->Entry->Header->Marked > 0)
  806.             HowManyMarked++;
  807.     }
  808.  
  809.     if(HowManyMarked > 0)
  810.     {
  811.         PhoneNode *Which;
  812.         LONG i,Counter;
  813.  
  814.         DetachList(Context);
  815.  
  816.         for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  817.             UnmarkDialEntry(Context->PhoneHandle,Node->Entry);
  818.  
  819.         for(i = 0 ; i < HowManyMarked ; i++)
  820.         {
  821.             Which    = NULL;
  822.             Counter    = -1;
  823.  
  824.             for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  825.             {
  826.                 if(Node->Entry->Header->Marked > 0)
  827.                 {
  828.                     if(Counter == -1 || Node->Entry->Header->Marked <= Counter)
  829.                     {
  830.                         Counter    = Node->Entry->Header->Marked;
  831.                         Which    = Node;
  832.                     }
  833.                 }
  834.             }
  835.  
  836.             if(Which)
  837.             {
  838.                 MarkDialEntry(Context->PhoneHandle,Which->Entry);
  839.                 Which->Entry->Header->Marked = 0;
  840.             }
  841.         }
  842.  
  843.         UpdateWindowTitle(Context);
  844.  
  845.         AttachList(Context);
  846.  
  847.         HighlightActiveEntry(Context,FALSE);
  848.     }
  849. }
  850.  
  851. STATIC VOID
  852. DeleteActiveEntry(PhoneListContext *Context)
  853. {
  854.     if(Context->SelectedNode)
  855.     {
  856.         if(Context->SelectedNode->Entry == GetActiveEntry(Context->PhoneHandle))
  857.             ShowRequest(Context->Window,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  858.         else
  859.         {
  860.             PhoneNode *NextNode;
  861.             LONG NextIndex;
  862.  
  863.             if(Context->NumEntries == 1)
  864.             {
  865.                 NextNode    = NULL;
  866.                 NextIndex    = -1;
  867.             }
  868.             else
  869.             {
  870.                 if(Context->SelectedIndex < Context->NumEntries - 1)
  871.                 {
  872.                     NextNode    = (PhoneNode *)Context->SelectedNode->Node.ln_Succ;
  873.                     NextIndex    = Context->SelectedIndex;
  874.                 }
  875.                 else
  876.                 {
  877.                     NextNode    = (PhoneNode *)Context->SelectedNode->Node.ln_Pred;
  878.                     NextIndex    = Context->SelectedIndex - 1;
  879.                 }
  880.             }
  881.  
  882.             DetachList(Context);
  883.  
  884.                 /* This is for keeping the dial list halfway intact. */
  885.  
  886.             if(Context->SelectedNode->Entry->DialNode)
  887.                 RemoveAndDeleteRelatedDialNodes(Context->PhoneHandle,Context->SelectedNode->Entry->DialNode);
  888.  
  889.             if(Context->PhoneHandle->DefaultGroup > 0)
  890.             {
  891.                 RemoveGroupEntry(Context->SelectedNode->Entry);
  892.                 DeleteGroupEntry(Context->SelectedNode->Entry);
  893.             }
  894.             else
  895.             {
  896.                 RemovePhoneEntry(Context->PhoneHandle,Context->SelectedNode->Entry);
  897.                 DeletePhoneEntry(Context->SelectedNode->Entry);
  898.             }
  899.  
  900.             Context->NumEntries--;
  901.  
  902.             Context->SelectedNode    = NextNode;
  903.             Context->SelectedIndex    = NextIndex;
  904.  
  905.             AttachList(Context);
  906.  
  907.             HighlightActiveEntry(Context,FALSE);
  908.  
  909.             if(!Context->NumEntries)
  910.                 CloseSomeWindow(Context,Context->GroupWindow);
  911.  
  912.             UpdateWindowTitle(Context);
  913.         }
  914.     }
  915. }
  916.  
  917. STATIC VOID
  918. CopyActiveEntry(PhoneListContext *Context)
  919. {
  920.     if(Context->SelectedNode)
  921.     {
  922.         PhoneEntry *Entry;
  923.  
  924.         UpdateEditorData(Context);
  925.  
  926.         if(Entry = ClonePhoneEntry(Context->PhoneHandle,Context->SelectedNode->Entry))
  927.         {
  928.             DetachList(Context);
  929.  
  930.                 /* Add the entry to the list */
  931.  
  932.             if(AddPhoneEntry(Context->PhoneHandle,Entry))
  933.             {
  934.                     /* Are we displaying a group? */
  935.  
  936.                 if(Context->PhoneHandle->DefaultGroup)
  937.                 {
  938.                         /* Link this entry into the group */
  939.  
  940.                     if(!AddGroupEntry(GetActiveGroup(Context),Entry))
  941.                     {
  942.                         RemovePhoneEntry(Context->PhoneHandle,Entry);
  943.                         DeletePhoneEntry(Entry);
  944.  
  945.                         Entry = NULL;
  946.                     }
  947.                 }
  948.             }
  949.  
  950.             if(Entry)
  951.             {
  952.                     /* Grab the new node */
  953.  
  954.                 Context->SelectedNode    = Entry->Node;
  955.                 Context->SelectedIndex    = Context->NumEntries++;
  956.  
  957.                 AttachList(Context);
  958.  
  959.                     /* Open the editor window so the user will be able to edit the new entry */
  960.  
  961.                 if(!Context->Editor)
  962.                 {
  963.                     if(Context->Editor = CreateEditorHandle(Context,TRUE))
  964.                         Context->EditWindow = Context->Editor->Window;
  965.                 }
  966.  
  967.                 HighlightActiveEntry(Context,TRUE);
  968.  
  969.                 UpdateWindowTitle(Context);
  970.  
  971.                 PhonebookChanged = TRUE;
  972.                 RebuildMenu = TRUE;
  973.                 ActivateJob(MainJobQueue,RebuildMenuJob);
  974.             }
  975.             else
  976.                 AttachList(Context);
  977.         }
  978.     }
  979. }
  980.  
  981. STATIC VOID
  982. LoadNewPhonebook(PhoneListContext *Context)
  983. {
  984.         /* If an entry is still in use, don't let the user replace */
  985.         /* the phonebook */
  986.  
  987.     if(GetActiveEntry(Context->PhoneHandle))
  988.         ShowRequest(Context->Window,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_LOAD_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  989.     else
  990.     {
  991.         UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  992.         struct FileRequester *FileRequest;
  993.         PhonebookHandle *LocalPhoneHandle;
  994.  
  995.         strcpy(DummyBuffer,LastPhone);
  996.  
  997.         if(FileRequest = OpenSingleFile(Context->Window,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  998.         {
  999.             FreeAslRequest(FileRequest);
  1000.  
  1001.             if(!(LocalPhoneHandle = LoadPhonebook(DummyBuffer)))
  1002.                 ShowError(Context->Window,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1003.         }
  1004.         else
  1005.             LocalPhoneHandle = NULL;
  1006.  
  1007.         if(LocalPhoneHandle)
  1008.         {
  1009.             STRPTR *OtherLabels;
  1010.  
  1011.                 /* The group labels need to be rebuilt. */
  1012.  
  1013.             if(OtherLabels = BuildLabels(LocalPhoneHandle))
  1014.             {
  1015.                 if(InitPhoneList(LocalPhoneHandle))
  1016.                 {
  1017.                     DetachList(Context);
  1018.  
  1019.                     CloseSomeWindow(Context,Context->GroupWindow);
  1020.  
  1021.                     LT_SetAttributes(Context->Manager,GAD_GROUPID,
  1022.                         GTCY_Active,    LocalPhoneHandle->DefaultGroup,
  1023.                         GTCY_Labels,    OtherLabels,
  1024.                     TAG_DONE);
  1025.  
  1026.                     FreeVecPooled(Context->GroupLabels);
  1027.                     Context->GroupLabels = OtherLabels;
  1028.  
  1029.                     if(GlobalPhoneHandle == Context->PhoneHandle)
  1030.                         GlobalPhoneHandle = LocalPhoneHandle;
  1031.  
  1032.                     DeletePhonebook(Context->PhoneHandle);
  1033.  
  1034.                     Context->PhoneHandle = LocalPhoneHandle;
  1035.                     Context->GroupLabels = OtherLabels;
  1036.  
  1037.                     if(Context->PhoneHandle->DefaultGroup > 0)
  1038.                     {
  1039.                         PhoneGroupNode *Group;
  1040.  
  1041.                             /* Grab the list we wanted */
  1042.  
  1043.                         Group = GetActiveGroup(Context);
  1044.  
  1045.                         Context->CurrentList = (struct List *)&Group->GroupList;
  1046.                         Context->NumEntries = GetListSize(Context->CurrentList);
  1047.                     }
  1048.                     else
  1049.                     {
  1050.                         Context->CurrentList = LocalPhoneHandle->PhoneList;
  1051.                         Context->NumEntries = LocalPhoneHandle->NumPhoneEntries;
  1052.                     }
  1053.  
  1054.                     Context->SelectedIndex    = -1;
  1055.                     Context->SelectedNode    = NULL;
  1056.  
  1057.                     LT_SetAttributes(Context->Manager,GAD_MAIN_AUTODIAL,
  1058.                         GTCB_Checked,    Context->PhoneHandle->AutoDial,
  1059.                     TAG_DONE);
  1060.  
  1061.                     LT_SetAttributes(Context->Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  1062.                         GA_Disabled,    !Context->PhoneHandle->AutoDial,
  1063.                         GTCB_Checked,    Context->PhoneHandle->AutoExit,
  1064.                     TAG_DONE);
  1065.  
  1066.                     AttachList(Context);
  1067.  
  1068.                     UpdateWindowTitle(Context);
  1069.  
  1070.                     strcpy(LastPhone,DummyBuffer);
  1071.                     strcpy(Config->PhonebookFileName,LastPhone);
  1072.  
  1073.                     PhonebookChanged = FALSE;
  1074.                     RebuildMenu = TRUE;
  1075.                     ActivateJob(MainJobQueue,RebuildMenuJob);
  1076.  
  1077.                     HighlightActiveEntry(Context,FALSE);
  1078.  
  1079.                     SelectIfMarked(Context);
  1080.  
  1081.                     OtherLabels = NULL;
  1082.                     LocalPhoneHandle = NULL;
  1083.                 }
  1084.  
  1085.                 FreeVecPooled(OtherLabels);
  1086.             }
  1087.  
  1088.             DeletePhonebook(LocalPhoneHandle);
  1089.         }
  1090.     }
  1091. }
  1092.  
  1093. STATIC VOID
  1094. MergeNewPhonebook(PhoneListContext *Context)
  1095. {
  1096.     UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  1097.     struct FileRequester *FileRequest;
  1098.     PhonebookHandle *LocalPhoneHandle;
  1099.  
  1100.     strcpy(DummyBuffer,LastPhone);
  1101.  
  1102.     if(FileRequest = OpenSingleFile(Context->Window,LocaleString(MSG_PHONEPANEL_LOAD_PHONEBOOK_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  1103.     {
  1104.         FreeAslRequest(FileRequest);
  1105.  
  1106.         if(!(LocalPhoneHandle = LoadPhonebook(DummyBuffer)))
  1107.             ShowError(Context->Window,ERR_LOAD_ERROR,IoErr(),DummyBuffer);
  1108.     }
  1109.     else
  1110.         LocalPhoneHandle = NULL;
  1111.  
  1112.     if(LocalPhoneHandle)
  1113.     {
  1114.         if(InitPhoneList(LocalPhoneHandle))
  1115.         {
  1116.             DetachList(Context);
  1117.  
  1118.             MergePhonebooks(LocalPhoneHandle,Context->PhoneHandle);
  1119.  
  1120.             AttachList(Context);
  1121.  
  1122.             if(Context->PhoneHandle->DefaultGroup == 0)
  1123.                 Context->NumEntries = GetListSize(Context->CurrentList);
  1124.  
  1125.             UpdateWindowTitle(Context);
  1126.  
  1127.             PhonebookChanged = TRUE;
  1128.             RebuildMenu = TRUE;
  1129.             ActivateJob(MainJobQueue,RebuildMenuJob);
  1130.         }
  1131.  
  1132.         DeletePhonebook(LocalPhoneHandle);
  1133.     }
  1134. }
  1135.  
  1136. STATIC VOID
  1137. ChangeGroup(PhoneListContext *Context)
  1138. {
  1139.     STRPTR Name;
  1140.     LONG Count;
  1141.  
  1142.     Count = Context->PhoneHandle->DialMarker;
  1143.  
  1144.         /* Which group should the tagged entries go into? */
  1145.  
  1146.     Name = LT_GetString(Context->Grouping,GAD_GROUP_NAME);
  1147.  
  1148.     DetachList(Context);
  1149.  
  1150.         /* If it's "All", then the entries will be removed from the */
  1151.         /* subgroups and end up in the main group */
  1152.  
  1153.     if(!Stricmp(Name,Context->GroupLabels[0]))
  1154.     {
  1155.         PhoneNode *Node,*Next;
  1156.  
  1157.         for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Next = (PhoneNode *)Node->Node.ln_Succ ; Node = Next)
  1158.         {
  1159.             if(Node->Entry->ThisGroup && Node->Entry->Count >= 0)
  1160.             {
  1161.                 RemoveGroupEntry(Node->Entry);
  1162.                 DeleteGroupEntry(Node->Entry);
  1163.             }
  1164.         }
  1165.     }
  1166.     else
  1167.     {
  1168.         PhoneGroupNode *WhichGroup,*GroupNode;
  1169.         BOOL RenameGroup,Success;
  1170.  
  1171.         WhichGroup    = NULL;
  1172.         RenameGroup    = TRUE,
  1173.         Success        = TRUE;
  1174.  
  1175.             /* Check if the requested group already exists. In this */
  1176.             /* case, the user wants to move entries from one group */
  1177.             /* to another. */
  1178.  
  1179.         for(GroupNode = (PhoneGroupNode *)Context->PhoneHandle->PhoneGroupList.mlh_Head ; GroupNode->Node.ln_Succ ; GroupNode = (PhoneGroupNode *)GroupNode->Node.ln_Succ)
  1180.         {
  1181.             if(!Stricmp(GroupNode->Node.ln_Name,Name))
  1182.             {
  1183.                 RenameGroup = FALSE;
  1184.                 break;
  1185.             }
  1186.         }
  1187.  
  1188.             /* Are we displaying a group list at all? */
  1189.  
  1190.         if(Context->PhoneHandle->DefaultGroup > 0)
  1191.         {
  1192.             struct PhoneNode *SomeNode;
  1193.  
  1194.             for(SomeNode = (struct PhoneNode *)Context->CurrentList->lh_Head ; SomeNode->Node.ln_Succ ; SomeNode = (struct PhoneNode *)SomeNode->Node.ln_Succ)
  1195.             {
  1196.                 if(SomeNode->Entry->Count >= 0)
  1197.                 {
  1198.                     WhichGroup = SomeNode->Entry->ThisGroup;
  1199.                     break;
  1200.                 }
  1201.             }
  1202.  
  1203.                 /* If there is no group to play with, don't rename it */
  1204.  
  1205.             if(!WhichGroup)
  1206.                 RenameGroup = FALSE;
  1207.         }
  1208.         else
  1209.             RenameGroup = FALSE;
  1210.  
  1211.             /* Check if the marked entries are already */
  1212.             /* members of the same group */
  1213.  
  1214.         if(RenameGroup)
  1215.         {
  1216.             PhoneEntry **Phonebook = Context->PhoneHandle->Phonebook;
  1217.             LONG i,NotGrouped = 0,InGroup = 0;
  1218.  
  1219.             for(i = 0 ; RenameGroup && i < Context->PhoneHandle->NumPhoneEntries ; i++)
  1220.             {
  1221.                 if(Phonebook[i]->Count != -1)
  1222.                 {
  1223.                     if(Phonebook[i]->ThisGroup)
  1224.                     {
  1225.                         if(NotGrouped)
  1226.                             RenameGroup = FALSE;
  1227.                         else
  1228.                         {
  1229.                             if(Phonebook[i]->ThisGroup == WhichGroup)
  1230.                                 InGroup++;
  1231.                             else
  1232.                                 RenameGroup = FALSE;
  1233.                         }
  1234.                     }
  1235.                     else
  1236.                     {
  1237.                         if(WhichGroup)
  1238.                             RenameGroup = FALSE;
  1239.                         else
  1240.                             NotGrouped++;
  1241.                     }
  1242.                 }
  1243.                 else
  1244.                 {
  1245.                     if(Phonebook[i]->ThisGroup == WhichGroup)
  1246.                         InGroup++;
  1247.                 }
  1248.             }
  1249.  
  1250.                 /* If we should continue, check if there are */
  1251.                 /* any group members at all and if all members */
  1252.                 /* of the group are selected. */
  1253.  
  1254.             if(NotGrouped || InGroup != Count)
  1255.                 RenameGroup = FALSE;
  1256.         }
  1257.  
  1258.         if(RenameGroup)
  1259.         {
  1260.             strcpy(WhichGroup->LocalName,Name);
  1261.  
  1262.             GroupNode = WhichGroup;
  1263.         }
  1264.         else
  1265.         {
  1266.                 /* Either find an existing group of the given name */
  1267.                 /* or make a new group. */
  1268.  
  1269.             if(GroupNode = CreatePhoneGroup(Context->PhoneHandle,Name))
  1270.             {
  1271.                 PhoneNode    *Node,*Next;
  1272.                 LONG         Total = 0;
  1273.  
  1274.                     /* Add the tagged entries to the group */
  1275.  
  1276.                 for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Next = (PhoneNode *)Node->Node.ln_Succ ; Node = Next)
  1277.                 {
  1278.                     if(Node->Entry->Count != -1)
  1279.                     {
  1280.                         AddGroupEntry(GroupNode,Node->Entry);
  1281.  
  1282.                         Total++;
  1283.                     }
  1284.                 }
  1285.  
  1286.                 if(!Total && Context->SelectedNode)
  1287.                 {
  1288.                     if(!AddGroupEntry(GroupNode,Context->SelectedNode->Entry))
  1289.                         Success = FALSE;
  1290.                 }
  1291.             }
  1292.             else
  1293.                 Success = FALSE;
  1294.         }
  1295.  
  1296.         if(Success)
  1297.         {
  1298.             STRPTR *OtherLabels;
  1299.  
  1300.                 /* Now update the labels */
  1301.  
  1302.             if(OtherLabels = BuildLabels(Context->PhoneHandle))
  1303.             {
  1304.                 PhoneGroupNode *This;
  1305.                 LONG GroupCounter;
  1306.  
  1307.                 LT_SetAttributes(Context->Manager,GAD_GROUPID,
  1308.                     GTCY_Labels,OtherLabels,
  1309.                 TAG_DONE);
  1310.  
  1311.                 FreeVecPooled(Context->GroupLabels);
  1312.                 Context->GroupLabels = OtherLabels;
  1313.  
  1314.                 Context->CurrentList = (struct List *)&GroupNode->GroupList;
  1315.  
  1316.                 for(This = (PhoneGroupNode *)Context->PhoneHandle->PhoneGroupList.mlh_Head, GroupCounter = 1 ; This->Node.ln_Succ ; This = (PhoneGroupNode *)This->Node.ln_Succ, GroupCounter++)
  1317.                 {
  1318.                     if(This == GroupNode)
  1319.                         break;
  1320.                 }
  1321.  
  1322.                 Context->PhoneHandle->DefaultGroup = GroupCounter;
  1323.  
  1324.                 if(Context->GroupWindow)
  1325.                 {
  1326.                     LT_SetAttributes(Context->Grouping,GAD_GROUP_LIST,
  1327.                         GTCY_Labels,    Context->GroupLabels,
  1328.                         GTCY_Active,    Context->PhoneHandle->DefaultGroup,
  1329.                     TAG_DONE);
  1330.                 }
  1331.  
  1332.                 LT_SetAttributes(Context->Manager,GAD_GROUPID,
  1333.                     GTCY_Labels,    Context->GroupLabels,
  1334.                     GTCY_Active,    Context->PhoneHandle->DefaultGroup,
  1335.                 TAG_DONE);
  1336.  
  1337.                 PhonebookChanged = TRUE;
  1338.                 RebuildMenu = TRUE;
  1339.                 ActivateJob(MainJobQueue,RebuildMenuJob);
  1340.             }
  1341.         }
  1342.     }
  1343.  
  1344.     Context->SelectedIndex    = -1;
  1345.     Context->SelectedNode    = NULL;
  1346.  
  1347.     AttachList(Context);
  1348.     HighlightActiveEntry(Context,FALSE);
  1349. }
  1350.  
  1351. STATIC VOID
  1352. SelectGroup(PhoneListContext *Context,LONG Index)
  1353. {
  1354.     Context->SelectedIndex    = -1;
  1355.     Context->SelectedNode    = NULL;
  1356.  
  1357.     DetachList(Context);
  1358.  
  1359.     Context->PhoneHandle->DefaultGroup = Index;
  1360.  
  1361.         /* Special group? */
  1362.  
  1363.     if(Context->PhoneHandle->DefaultGroup > 0)
  1364.     {
  1365.         PhoneGroupNode *Group;
  1366.  
  1367.             /* Grab the list we wanted */
  1368.  
  1369.         Group = GetActiveGroup(Context);
  1370.  
  1371.         Context->CurrentList    = (struct List *)&Group->GroupList;
  1372.         Context->NumEntries        = GetListSize(Context->CurrentList);
  1373.     }
  1374.     else
  1375.     {
  1376.         if(Context->PhoneHandle->PhoneList)
  1377.         {
  1378.             Context->CurrentList    = Context->PhoneHandle->PhoneList;
  1379.             Context->NumEntries        = Context->PhoneHandle->NumPhoneEntries;
  1380.         }
  1381.         else
  1382.         {
  1383.             STATIC struct List EmptyList;
  1384.  
  1385.             NewList(&EmptyList);
  1386.  
  1387.             Context->CurrentList    = &EmptyList;
  1388.             Context->NumEntries        = 0;
  1389.         }
  1390.     }
  1391.  
  1392.     AttachList(Context);
  1393.     HighlightActiveEntry(Context,FALSE);
  1394. }
  1395.  
  1396. STATIC VOID
  1397. SplitGroup(PhoneListContext *Context)
  1398. {
  1399.     PhoneGroupNode *PhoneGroup;
  1400.     STRPTR *OtherLabels;
  1401.  
  1402.     DetachList(Context);
  1403.  
  1404.     PhoneGroup = GetActiveGroup(Context);
  1405.  
  1406.     Remove((struct Node *)PhoneGroup);
  1407.  
  1408.     if(OtherLabels = BuildLabels(Context->PhoneHandle))
  1409.     {
  1410.         CloseSomeWindow(Context,Context->GroupWindow);
  1411.  
  1412.         DeletePhoneGroupNode(PhoneGroup);
  1413.  
  1414.         Context->PhoneHandle->DefaultGroup = 0;
  1415.  
  1416.         Context->CurrentList    = Context->PhoneHandle->PhoneList;
  1417.         Context->NumEntries        = Context->PhoneHandle->NumPhoneEntries;
  1418.  
  1419.         Context->SelectedNode    = NULL;
  1420.         Context->SelectedIndex    = -1;
  1421.  
  1422.         LT_SetAttributes(Context->Manager,GAD_GROUPID,
  1423.             GTCY_Labels,OtherLabels,
  1424.             GTCY_Active,0,
  1425.         TAG_DONE);
  1426.  
  1427.         FreeVecPooled(Context->GroupLabels);
  1428.         Context->GroupLabels = OtherLabels;
  1429.  
  1430.         PhonebookChanged = TRUE;
  1431.     }
  1432.     else
  1433.         InsertSorted((struct List *)&Context->PhoneHandle->PhoneGroupList,(struct Node *)PhoneGroup);
  1434.  
  1435.     AttachList(Context);
  1436.     HighlightActiveEntry(Context,FALSE);
  1437. }
  1438.  
  1439. STATIC VOID
  1440. SortThePhonebook(PhoneListContext *Context,LONG How,BOOL ReverseOrder)
  1441. {
  1442.     DetachList(Context);
  1443.  
  1444.     if(Context->PhoneHandle->DefaultGroup > 0)
  1445.         SortGroupList(Context->CurrentList,How,ReverseOrder);
  1446.     else
  1447.     {
  1448.         SortPhoneList(Context->PhoneHandle,How,ReverseOrder);
  1449.         UpdatePhoneList(Context->PhoneHandle);
  1450.     }
  1451.  
  1452.     Context->SelectedNode    = NULL;
  1453.     Context->SelectedIndex    = -1;
  1454.  
  1455.     PhonebookChanged = TRUE;
  1456.     RebuildMenu = TRUE;
  1457.     ActivateJob(MainJobQueue,RebuildMenuJob);
  1458.  
  1459.     AttachList(Context);
  1460.     HighlightActiveEntry(Context,FALSE);
  1461. }
  1462.  
  1463. STATIC VOID
  1464. SelectNewTaggedEntry(PhoneListContext *Context,LONG How)
  1465. {
  1466.     if(Context->SelectedNode)
  1467.     {
  1468.         PhoneNode *SelectedNode = Context->SelectedNode;
  1469.  
  1470.         if(SelectedNode->Entry->Count >= 0)
  1471.         {
  1472.             LONG i,Which;
  1473.             BOOL ListIsReady;
  1474.  
  1475.             DetachList(Context);
  1476.             ListIsReady = FALSE;
  1477.  
  1478.             switch(How)
  1479.             {
  1480.                 case MOVE_HEAD:
  1481.  
  1482.                     Which = 0;
  1483.                     break;
  1484.  
  1485.                 case MOVE_PRED:
  1486.  
  1487.                     Which = SelectedNode->Entry->Count - 1;
  1488.                     break;
  1489.  
  1490.                 case MOVE_SUCC:
  1491.  
  1492.                     Which = SelectedNode->Entry->Count + 1;
  1493.                     break;
  1494.  
  1495.                 case MOVE_TAIL:
  1496.  
  1497.                     Which = Context->PhoneHandle->DialMarker - 1;
  1498.                     break;
  1499.             }
  1500.  
  1501.             if(Which >= 0 && Which < Context->PhoneHandle->DialMarker)
  1502.             {
  1503.                 PhoneEntry **Phonebook = Context->PhoneHandle->Phonebook;
  1504.  
  1505.                 for(i = 0 ; i < Context->PhoneHandle->NumPhoneEntries ; i++)
  1506.                 {
  1507.                     if(Phonebook[i]->Node->Entry->Count == Which)
  1508.                     {
  1509.                         LONG NodeIndex;
  1510.  
  1511.                         UpdateEditorData(Context);
  1512.  
  1513.                         SelectedNode = Phonebook[i]->Node;
  1514.  
  1515.                         if(SelectedNode->Entry->GroupNode)
  1516.                         {
  1517.                             PhoneGroupNode *GroupNode;
  1518.                             LONG GroupIndex;
  1519.  
  1520.                             SelectedNode = SelectedNode->Entry->GroupNode;
  1521.  
  1522.                             FindGroup((struct List *)&Context->PhoneHandle->PhoneGroupList,&GroupIndex,&NodeIndex,SelectedNode);
  1523.  
  1524.                             Context->PhoneHandle->DefaultGroup = GroupIndex;
  1525.  
  1526.                             GroupNode = GetActiveGroup(Context);
  1527.  
  1528.                             Context->CurrentList    = (struct List *)&GroupNode->GroupList;
  1529.                             Context->NumEntries        = GetListSize(Context->CurrentList);
  1530.                         }
  1531.                         else
  1532.                         {
  1533.                             Context->PhoneHandle->DefaultGroup = 0;
  1534.  
  1535.                             Context->CurrentList    = Context->PhoneHandle->PhoneList;
  1536.                             Context->NumEntries        = Context->PhoneHandle->NumPhoneEntries;
  1537.  
  1538.                             NodeIndex = i;
  1539.                         }
  1540.  
  1541.                         Context->SelectedNode    = SelectedNode;
  1542.                         Context->SelectedIndex    = NodeIndex;
  1543.  
  1544.                         AttachList(Context);
  1545.                         ListIsReady = TRUE;
  1546.  
  1547.                         HighlightActiveEntry(Context,FALSE);
  1548.  
  1549.                         break;
  1550.                     }
  1551.                 }
  1552.             }
  1553.  
  1554.             if(!ListIsReady)
  1555.                 AttachList(Context);
  1556.         }
  1557.     }
  1558. }
  1559.  
  1560. STATIC VOID
  1561. MoveActiveEntry(PhoneListContext *Context,LONG How)
  1562. {
  1563.     if(Context->SelectedNode != NULL)
  1564.     {
  1565.         DetachList(Context);
  1566.  
  1567.         if(Context->PhoneHandle->DefaultGroup == 0)
  1568.             Context->SelectedIndex = MovePhoneEntry(Context->PhoneHandle,Context->SelectedIndex,How);
  1569.         else
  1570.         {
  1571.             LONG NewPosition;
  1572.  
  1573.             switch(How)
  1574.             {
  1575.                 case MOVE_HEAD:
  1576.  
  1577.                     NewPosition = 0;
  1578.                     break;
  1579.  
  1580.                 case MOVE_PRED:
  1581.  
  1582.                     NewPosition = Context->SelectedIndex - 1;
  1583.                     break;
  1584.  
  1585.                 case MOVE_SUCC:
  1586.  
  1587.                     NewPosition = Context->SelectedIndex + 1;
  1588.                     break;
  1589.  
  1590.                 case MOVE_TAIL:
  1591.  
  1592.                     NewPosition = Context->NumEntries - 1;
  1593.                     break;
  1594.             }
  1595.  
  1596.             if(NewPosition >= 0 && NewPosition < Context->NumEntries)
  1597.             {
  1598.                 MoveNode(Context->CurrentList,(struct Node *)Context->SelectedNode,How);
  1599.  
  1600.                 Context->SelectedIndex = NewPosition;
  1601.             }
  1602.         }
  1603.  
  1604.         AttachList(Context);
  1605.  
  1606.         HighlightActiveEntry(Context,FALSE);
  1607.     }
  1608. }
  1609.  
  1610. STATIC VOID
  1611. AddNewEntry(PhoneListContext *Context)
  1612. {
  1613.     PhoneEntry *Entry;
  1614.  
  1615.     UpdateEditorData(Context);
  1616.  
  1617.     DetachList(Context);
  1618.  
  1619.         /* Create the new entry */
  1620.  
  1621.     if(Entry = CreatePhoneEntry(Context->PhoneHandle))
  1622.     {
  1623.             /* Add the entry to the list */
  1624.  
  1625.         if(AddPhoneEntry(Context->PhoneHandle,Entry))
  1626.         {
  1627.                 /* Are we displaying a group? */
  1628.  
  1629.             if(Context->PhoneHandle->DefaultGroup)
  1630.             {
  1631.                 PhoneGroupNode *Group;
  1632.  
  1633.                     /* Link this entry into the group */
  1634.  
  1635.                 Group = GetActiveGroup(Context);
  1636.  
  1637.                 if(!AddGroupEntry(Group,Entry))
  1638.                 {
  1639.                     RemovePhoneEntry(Context->PhoneHandle,Entry);
  1640.                     DeletePhoneEntry(Entry);
  1641.  
  1642.                     Entry = NULL;
  1643.                 }
  1644.             }
  1645.         }
  1646.         else
  1647.         {
  1648.             DeletePhoneEntry(Entry);
  1649.  
  1650.             Entry = NULL;
  1651.         }
  1652.     }
  1653.  
  1654.     if(Entry)
  1655.     {
  1656.             /* Grab the new node */
  1657.  
  1658.         Context->SelectedNode    = Entry->Node;
  1659.         Context->SelectedIndex    = Context->NumEntries++;
  1660.  
  1661.         AttachList(Context);
  1662.  
  1663.             /* Open the editor window so the user can edit the new entry */
  1664.  
  1665.         if(!Context->Editor)
  1666.         {
  1667.             if(Context->Editor = CreateEditorHandle(Context,TRUE))
  1668.                 Context->EditWindow = Context->Editor->Window;
  1669.         }
  1670.  
  1671.         HighlightActiveEntry(Context,TRUE);
  1672.         UpdateWindowTitle(Context);
  1673.  
  1674.         PhonebookChanged = TRUE;
  1675.         RebuildMenu = TRUE;
  1676.         ActivateJob(MainJobQueue,RebuildMenuJob);
  1677.     }
  1678.     else
  1679.         AttachList(Context);
  1680. }
  1681.  
  1682. BOOL
  1683. PhonePanel(ULONG InitialQualifier)
  1684. {
  1685.     STATIC UBYTE    NamePattern[64]        = "#?",
  1686.                     NumberPattern[64]    = "#?",
  1687.                     CommentPattern[64]    = "#?";
  1688.     STATIC BYTE        Mode = 1;
  1689.  
  1690.     STATIC WORD        Criteria;
  1691.     STATIC BOOL        ReverseOrder;
  1692.  
  1693.     /************************************************************************/
  1694.  
  1695.     UBYTE                 ParsedNamePattern[2 * sizeof(NamePattern) + 2],
  1696.                          ParsedNumberPattern[2 * sizeof(NumberPattern) + 2],
  1697.                          ParsedCommentPattern[2 * sizeof(CommentPattern) + 2];
  1698.     PhoneListContext    *Context;
  1699.     UBYTE                 NewPassword[MAX_PASSWORD_LENGTH+1];
  1700.     PhoneNode            *Node;
  1701.     BOOL                 Changes;
  1702.     BOOL                 DialTheList = FALSE;
  1703.  
  1704.         /* Set up the list context */
  1705.  
  1706.     if(!(Context = CreatePhoneListContext(GlobalPhoneHandle)))
  1707.     {
  1708.         DisplayBeep(Window->WScreen);
  1709.         return(FALSE);
  1710.     }
  1711.  
  1712.         /* If the user holds down any shift key, the editor window will open in */
  1713.         /* addition to the manager window */
  1714.  
  1715.     if(InitialQualifier & SHIFT_KEY)
  1716.     {
  1717.         if(Context->Editor = CreateEditorHandle(Context,FALSE))
  1718.             Context->EditWindow = Context->Editor->Window;
  1719.     }
  1720.  
  1721.         /* Don't go any further if the manager window is not open */
  1722.  
  1723.     if(Context->Manager = CreateManagerHandle(Context,Context->Editor ? Context->EditWindow : Window))
  1724.     {
  1725.         struct IntuiMessage        *Message;
  1726.         ULONG                     MsgClass,
  1727.                                  MsgQualifier;
  1728.         UWORD                     MsgCode;
  1729.         LONG                     KeyCode;
  1730.         struct Gadget            *MsgGadget;
  1731.         LONG                     MsgGadgetID;
  1732.         struct Window            *MsgWindow;
  1733.         ULONG                     CompleteQualifier;
  1734.         LONG                     ClickAction;
  1735.         LayoutHandle            *Handle;
  1736.         BOOL                     Done = FALSE;
  1737.  
  1738.             /* We will need these pointers later */
  1739.  
  1740.         Context->Window = Context->Manager->Window;
  1741.  
  1742.         GuideContext(CONTEXT_PHONEBOOK);
  1743.  
  1744.         PushWindow(Context->Window);
  1745.  
  1746.             /* Select the entries that need to be selected. */
  1747.  
  1748.         SelectIfMarked(Context);
  1749.  
  1750.         do
  1751.         {
  1752.             if(Wait(PORTMASK(Context->WindowPort) | SIG_BREAK) & SIG_BREAK)
  1753.                 break;
  1754.  
  1755.             while(Message = (struct IntuiMessage *)GT_GetIMsg(Context->WindowPort))
  1756.             {
  1757.                 MsgClass        = Message->Class;
  1758.                 MsgQualifier    = Message->Qualifier;
  1759.                 MsgCode            = Message->Code;
  1760.                 MsgGadget        = (struct Gadget *)Message->IAddress;
  1761.                 MsgWindow        = Message->IDCMPWindow;
  1762.  
  1763.                 GT_ReplyIMsg(Message);
  1764.  
  1765.                     /* Jump to the handle the message originated from */
  1766.  
  1767.                 if(MsgWindow == Context->Window)
  1768.                     Handle = Context->Manager;
  1769.  
  1770.                 if(MsgWindow == Context->EditWindow)
  1771.                     Handle = Context->Editor;
  1772.  
  1773.                 if(MsgWindow == Context->PatternWindow)
  1774.                     Handle = Context->Selector;
  1775.  
  1776.                 if(MsgWindow == Context->GroupWindow)
  1777.                     Handle = Context->Grouping;
  1778.  
  1779.                 if(MsgWindow == Context->SortWindow)
  1780.                     Handle = Context->Sorting;
  1781.  
  1782.                 if(MsgWindow == Context->PasswordWindow)
  1783.                     Handle = Context->PasswordHandle;
  1784.  
  1785.                     /* Save the original event qualifier */
  1786.  
  1787.                 CompleteQualifier = MsgQualifier;
  1788.  
  1789.                     /* Now, this is not nice, but needs to be done in order */
  1790.                     /* to avoid having keyboard movements mess up the list of */
  1791.                     /* tagged entries. */
  1792.  
  1793.                 if(MsgClass == IDCMP_RAWKEY && (MsgCode >= CURSORUP && MsgCode <= CURSORDOWN))
  1794.                     MsgQualifier &= ~SHIFT_KEY;
  1795.  
  1796.                     /* We'll save the key code for the editing window */
  1797.  
  1798.                 if(MsgClass == IDCMP_RAWKEY)
  1799.                     KeyCode = MsgCode;
  1800.                 else
  1801.                     KeyCode = 0;
  1802.  
  1803.                     /* Let gtlayout take its share */
  1804.  
  1805.                 LT_HandleInput(Handle,CompleteQualifier,&MsgClass,&MsgCode,&MsgGadget);
  1806.  
  1807.                     /* Extract the gadget ID */
  1808.  
  1809.                 if(MsgClass == IDCMP_GADGETUP || MsgClass == IDCMP_IDCMPUPDATE)
  1810.                     MsgGadgetID = MsgGadget->GadgetID;
  1811.                 else
  1812.                     MsgGadgetID = -1;
  1813.  
  1814.                     /* Now convert the raw key code for special commands */
  1815.  
  1816.                 switch(LT_GetCode(CompleteQualifier,MsgClass,MsgCode,MsgGadget))
  1817.                 {
  1818.                         /* Toggle the current entry */
  1819.  
  1820.                     case ' ':
  1821.  
  1822.                         ChangeActiveEntry(Context,CHANGE_Toggle);
  1823.                         break;
  1824.  
  1825.                         /* Untag this or all entries */
  1826.  
  1827.                     case 127:
  1828.  
  1829.                         if(CompleteQualifier & SHIFT_KEY)
  1830.                         {
  1831.                             if(Context->PhoneHandle->DialMarker > 0)
  1832.                             {
  1833.                                 MsgClass    = IDCMP_GADGETUP;
  1834.                                 MsgGadgetID    = GAD_CLEAR_ALL;
  1835.  
  1836.                                 LT_PressButton(Handle,MsgGadgetID);
  1837.                             }
  1838.                         }
  1839.                         else
  1840.                         {
  1841.                             if(Context->SelectedNode != NULL && Context->SelectedNode->Entry->Count != -1)
  1842.                             {
  1843.                                 MsgClass    = IDCMP_GADGETUP;
  1844.                                 MsgGadgetID    = GAD_CLEAR;
  1845.  
  1846.                                 LT_PressButton(Handle,MsgGadgetID);
  1847.                             }
  1848.                         }
  1849.  
  1850.                         break;
  1851.                 }
  1852.  
  1853.                     /* Moving around through the editing window */
  1854.  
  1855.                 if(KeyCode != 0 && MsgWindow == Context->EditWindow)
  1856.                 {
  1857.                     switch(KeyCode)
  1858.                     {
  1859.                         case CURSORLEFT:
  1860.  
  1861.                             MsgGadgetID = -1;
  1862.  
  1863.                             if(Context->SelectedNode && Context->SelectedNode->Entry->Count > 0)
  1864.                             {
  1865.                                 MsgClass = IDCMP_GADGETUP;
  1866.  
  1867.                                 if(CompleteQualifier & SHIFT_KEY)
  1868.                                     MsgGadgetID    = GAD_FIRST_ENTRY;
  1869.                                 else
  1870.                                     MsgGadgetID    = GAD_PREVIOUS_ENTRY;
  1871.  
  1872.                                 LT_PressButton(Handle,MsgGadgetID);
  1873.                             }
  1874.  
  1875.                             break;
  1876.  
  1877.                         case CURSORRIGHT:
  1878.  
  1879.                             MsgGadgetID = -1;
  1880.  
  1881.                             if(Context->SelectedNode && Context->SelectedNode->Entry->Count < Context->PhoneHandle->DialMarker - 1)
  1882.                             {
  1883.                                 MsgClass = IDCMP_GADGETUP;
  1884.  
  1885.                                 if(CompleteQualifier & SHIFT_KEY)
  1886.                                     MsgGadgetID    = GAD_LAST_ENTRY;
  1887.                                 else
  1888.                                     MsgGadgetID    = GAD_NEXT_ENTRY;
  1889.  
  1890.                                 LT_PressButton(Handle,MsgGadgetID);
  1891.                             }
  1892.  
  1893.                             break;
  1894.                     }
  1895.                 }
  1896.  
  1897.                     /* Close a window */
  1898.  
  1899.                 if(MsgClass == IDCMP_CLOSEWINDOW)
  1900.                 {
  1901.                     if(MsgWindow == Context->Window)
  1902.                         Done = TRUE;
  1903.                     else
  1904.                         CloseSomeWindow(Context,MsgWindow);
  1905.                 }
  1906.  
  1907.                     /* Hit a gadget */
  1908.  
  1909.                 if(MsgClass == IDCMP_GADGETUP)
  1910.                 {
  1911.                     switch(MsgGadgetID)
  1912.                     {
  1913.                             /* Toggle all entries */
  1914.  
  1915.                         case GAD_TOGGLE_ALL:
  1916.  
  1917.                             ToggleAllEntries(Context);
  1918.                             break;
  1919.  
  1920.                             /* Select all entries */
  1921.  
  1922.                         case GAD_SELECT_ALL:
  1923.  
  1924.                             SelectAllEntries(Context);
  1925.                             break;
  1926.  
  1927.                             /* Clear all selections in this group */
  1928.  
  1929.                         case GAD_CLEAR_ALL:
  1930.  
  1931.                             ClearAllEntries(Context);
  1932.                             break;
  1933.  
  1934.                             /* Picked a list entry */
  1935.  
  1936.                         case GAD_NAMELIST:
  1937.  
  1938.                             UpdateEditorData(Context);
  1939.  
  1940.                             if(MsgQualifier & SHIFT_KEY)
  1941.                                 ClickAction = CLICK_Toggle;
  1942.                             else
  1943.                                 ClickAction = CLICK_Select;
  1944.  
  1945.                             if(MsgCode == Context->SelectedIndex)
  1946.                             {
  1947.                                 if(ClickAction == CLICK_Toggle)
  1948.                                     ChangeActiveEntry(Context,CHANGE_Toggle);
  1949.                             }
  1950.                             else
  1951.                             {
  1952.                                 SelectActiveEntry(Context,MsgCode,FALSE);
  1953.  
  1954.                                 if(ClickAction == CLICK_Toggle)
  1955.                                     ChangeActiveEntry(Context,CHANGE_Toggle);
  1956.                             }
  1957.  
  1958.                             break;
  1959.  
  1960.                             /* Print the current group */
  1961.  
  1962.                         case GAD_PRINT:
  1963.  
  1964.                             LockInterface(Context);
  1965.  
  1966.                             PrintPanel(Context->Window,Context->CurrentList,Context->PhoneHandle->DialMarker);
  1967.  
  1968.                             UnlockInterface(Context);
  1969.  
  1970.                             LT_ShowWindow(Handle,TRUE);
  1971.  
  1972.                             break;
  1973.  
  1974.                             /* Copy the setting stored with the current entry */
  1975.                             /* into the global settings */
  1976.  
  1977.                         case GAD_USE:
  1978.  
  1979.                             if(Context->SelectedNode)
  1980.                             {
  1981.                                 PhoneEntry *Entry = Context->SelectedNode->Entry;
  1982.  
  1983.                                 UpdateEditorData(Context);
  1984.  
  1985.                                 SaveConfig(Config,PrivateConfig);
  1986.                                 SaveConfig(Entry->Config,Config);
  1987.  
  1988.                                 strcpy(Password,Entry->Header->Password);
  1989.                                 strcpy(UserName,Entry->Header->UserName);
  1990.  
  1991.                                 ConfigSetup();
  1992.  
  1993.                                 Done = TRUE;
  1994.  
  1995.                                 ConfigChanged = FALSE;
  1996.                             }
  1997.  
  1998.                             break;
  1999.  
  2000.                             /* Add a new phonebook entry to the group */
  2001.  
  2002.                         case GAD_ADD:
  2003.  
  2004.                             AddNewEntry(Context);
  2005.                             break;
  2006.  
  2007.                             /* Edit the current entry */
  2008.  
  2009.                         case GAD_EDIT:
  2010.  
  2011.                             UpdateEditorData(Context);
  2012.  
  2013.                             if(Context->SelectedNode)
  2014.                             {
  2015.                                 if(!Context->Editor)
  2016.                                 {
  2017.                                     if(Context->Editor = CreateEditorHandle(Context,TRUE))
  2018.                                         Context->EditWindow = Context->Editor->Window;
  2019.                                 }
  2020.                                 else
  2021.                                     HighlightActiveEntry(Context,TRUE);
  2022.                             }
  2023.  
  2024.                             break;
  2025.  
  2026.                             /* Hide user name and password? */
  2027.  
  2028.                         case GAD_HIDE_USERNAME_PASSWORD:
  2029.  
  2030.                             if(Context->SelectedNode && !Context->Hide)
  2031.                             {
  2032.                                 PhoneEntry *Entry = Context->SelectedNode->Entry;
  2033.  
  2034.                                 strcpy(Entry->Header->UserName,LT_GetString(Context->Editor,GAD_USER_NAME));
  2035.                                 strcpy(Entry->Header->Password,LT_GetString(Context->Editor,GAD_USER_PASSWORD));
  2036.                             }
  2037.  
  2038.                             Context->Hide = MsgCode;
  2039.  
  2040.                             UpdateActiveEntry(Context);
  2041.  
  2042.                             break;
  2043.  
  2044.                             /* Change the system name; this is what shows up in the list */
  2045.  
  2046.                         case GAD_SYSTEM_NAME:
  2047.  
  2048.                             if(Context->SelectedNode)
  2049.                             {
  2050.                                 DetachList(Context);
  2051.  
  2052.                                 strcpy(Context->SelectedNode->Entry->Header->Name,LT_GetString(Context->Editor,GAD_SYSTEM_NAME));
  2053.                                 UpdatePhoneNode(Context->SelectedNode);
  2054.  
  2055.                                 UpdateActiveEntry(Context);
  2056.  
  2057.                                 PhonebookChanged = TRUE;
  2058.                                 RebuildMenu = TRUE;
  2059.                                 ActivateJob(MainJobQueue,RebuildMenuJob);
  2060.  
  2061.                                 if(MsgCode == '\r')
  2062.                                     LT_Activate(Context->Editor,GAD_COMMENT);
  2063.                             }
  2064.  
  2065.                             break;
  2066.  
  2067.                             /* Change the comment; this is what shows up directly below the list */
  2068.  
  2069.                         case GAD_COMMENT:
  2070.  
  2071.                             if(Context->SelectedNode)
  2072.                             {
  2073.                                 PhoneEntry *Entry = Context->SelectedNode->Entry;
  2074.  
  2075.                                 strcpy(Entry->Header->Comment,LT_GetString(Context->Editor,GAD_COMMENT));
  2076.  
  2077.                                 PhonebookChanged = TRUE;
  2078.  
  2079.                                 if(MsgCode == '\r')
  2080.                                     LT_Activate(Handle,GAD_NUMBERS);
  2081.  
  2082.                                 LT_SetAttributes(Context->Manager,GAD_COMMENTLINE,
  2083.                                     GTTX_Text,    Entry->Header->Comment,
  2084.                                 TAG_DONE);
  2085.                             }
  2086.  
  2087.                             break;
  2088.  
  2089.                             /* Put this entry into the quick dial menu or don't */
  2090.  
  2091.                         case GAD_QUICK_MENU:
  2092.  
  2093.                             if(Context->SelectedNode)
  2094.                             {
  2095.                                 PhoneHeader *Header = Context->SelectedNode->Entry->Header;
  2096.  
  2097.                                 if(Header->QuickMenu != MsgCode)
  2098.                                 {
  2099.                                     Header->QuickMenu = MsgCode;
  2100.  
  2101.                                     PhonebookChanged = TRUE;
  2102.                                     RebuildMenu = TRUE;
  2103.                                     ActivateJob(MainJobQueue,RebuildMenuJob);
  2104.                                 }
  2105.                             }
  2106.  
  2107.                             break;
  2108.  
  2109.                             /* Do the same for the autodial feature */
  2110.  
  2111.                         case GAD_AUTODIAL:
  2112.  
  2113.                             if(Context->SelectedNode)
  2114.                                 Context->SelectedNode->Entry->Header->AutoDial = MsgCode;
  2115.  
  2116.                             break;
  2117.  
  2118.                             /* Change the phone numbers for this entry */
  2119.  
  2120.                         case GAD_NUMBERS:
  2121.  
  2122.                             if(Context->SelectedNode)
  2123.                             {
  2124.                                 PhoneEntry *Entry = Context->SelectedNode->Entry;
  2125.  
  2126.                                 strcpy(Entry->Header->Number,LT_GetString(Context->Editor,GAD_NUMBERS));
  2127.  
  2128.                                 PhonebookChanged = TRUE;
  2129.  
  2130.                                 UpdateActiveEntry(Context);
  2131.                             }
  2132.  
  2133.                             break;
  2134.  
  2135.                             /* Change the user name */
  2136.  
  2137.                         case GAD_USER_NAME:
  2138.  
  2139.                             if(Context->SelectedNode)
  2140.                             {
  2141.                                 strcpy(Context->SelectedNode->Entry->Header->UserName,LT_GetString(Context->Editor,GAD_USER_NAME));
  2142.  
  2143.                                 PhonebookChanged = TRUE;
  2144.                             }
  2145.  
  2146.                             break;
  2147.  
  2148.                             /* Change the login password */
  2149.  
  2150.                         case GAD_USER_PASSWORD:
  2151.  
  2152.                             if(Context->SelectedNode)
  2153.                             {
  2154.                                 strcpy(Context->SelectedNode->Entry->Header->Password,LT_GetString(Context->Editor,GAD_USER_PASSWORD));
  2155.  
  2156.                                 PhonebookChanged = TRUE;
  2157.                             }
  2158.  
  2159.                             break;
  2160.  
  2161.                             /* Join the currently tagged entries in a new group */
  2162.  
  2163.                         case GAD_MAKE_GROUP:
  2164.  
  2165.                             if(Context->GroupWindow)
  2166.                             {
  2167.                                 LT_ShowWindow(Context->Grouping,TRUE);
  2168.                                 LT_Activate(Context->Grouping,GAD_GROUP_NAME);
  2169.                             }
  2170.                             else
  2171.                             {
  2172.                                 if(Context->Grouping = CreateGroupHandle(Context->Window,Context->GroupLabels,Context->PhoneHandle->DefaultGroup))
  2173.                                     Context->GroupWindow = Context->Grouping->Window;
  2174.                             }
  2175.  
  2176.                             break;
  2177.  
  2178.                             /* Close the grouping window without doing anything */
  2179.  
  2180.                         case GAD_GROUP_CANCEL:
  2181.  
  2182.                             CloseSomeWindow(Context,Context->GroupWindow);
  2183.                             break;
  2184.  
  2185.                             /* Open the sort window */
  2186.  
  2187.                         case GAD_SORT:
  2188.  
  2189.                             if(Context->Sorting)
  2190.                                 LT_ShowWindow(Context->Sorting,TRUE);
  2191.                             else
  2192.                             {
  2193.                                 if(Context->Sorting = CreateSortHandle(Context->Window,&Criteria,&ReverseOrder))
  2194.                                     Context->SortWindow = Context->Sorting->Window;
  2195.                                 else
  2196.                                     DisplayBeep(Context->Window->WScreen);
  2197.                             }
  2198.  
  2199.                             break;
  2200.  
  2201.                             /* Copy cofiguration data around */
  2202.  
  2203.                         case GAD_COPY_CONFIG:
  2204.  
  2205.                             LockInterface(Context);
  2206.  
  2207.                             if(!Context->SelectedNode)
  2208.                                 Changes = CopyPanel(Context->Window,NULL,Context->PhoneHandle->DialMarker > 0);
  2209.                             else
  2210.                                 Changes = CopyPanel(Context->Window,Context->SelectedNode->Entry->Config,Context->PhoneHandle->DialMarker > 0);
  2211.  
  2212.                             if(Changes)
  2213.                             {
  2214.                                 HighlightActiveEntry(Context,FALSE);
  2215.  
  2216.                                 PhonebookChanged = TRUE;
  2217.                             }
  2218.  
  2219.                             UnlockInterface(Context);
  2220.  
  2221.                             LT_ShowWindow(Context->Manager,TRUE);
  2222.  
  2223.                             break;
  2224.  
  2225.                             /* Change or clear the password */
  2226.  
  2227.                         case GAD_PASSWORD:
  2228.  
  2229.                             if(Context->PasswordWindow)
  2230.                                 LT_ShowWindow(Context->PasswordHandle,TRUE);
  2231.                             else
  2232.                             {
  2233.                                 if(Context->PasswordHandle = CreatePasswordHandle(Context->Window,Context->PhoneHandle->PhonePasswordUsed))
  2234.                                     Context->PasswordWindow = Context->PasswordHandle->Window;
  2235.                                 else
  2236.                                     DisplayBeep(Context->Window->WScreen);
  2237.                             }
  2238.  
  2239.                             break;
  2240.  
  2241.                             /* Changed the new password */
  2242.  
  2243.                         case GAD_NEW_PASSWORD:
  2244.                         case GAD_REPEAT_PASSWORD:
  2245.  
  2246.                             UpdatePasswordWindow(Context->PasswordHandle);
  2247.                             break;
  2248.  
  2249.                         case GAD_CLEAR_PASSWORD:
  2250.  
  2251.                             Context->PhoneHandle->PhonePasswordUsed = FALSE;
  2252.  
  2253.                             PhonebookChanged = TRUE;
  2254.  
  2255.                             CloseSomeWindow(Context,Context->PasswordWindow);
  2256.  
  2257.                             break;
  2258.  
  2259.                         case GAD_CANCEL_PASSWORD:
  2260.  
  2261.                             CloseSomeWindow(Context,Context->PasswordWindow);
  2262.                             break;
  2263.  
  2264.                         case GAD_USE_NEW_PASSWORD:
  2265.  
  2266.                             memset(NewPassword,0,sizeof(NewPassword));
  2267.  
  2268.                             if(GetWindowPassword(Handle,NewPassword))
  2269.                             {
  2270.                                 PhonebookChanged = TRUE;
  2271.                                 Context->PhoneHandle->PhonePasswordUsed = TRUE;
  2272.  
  2273.                                 Encrypt(NewPassword,MAX_PASSWORD_LENGTH,Context->PhoneHandle->PhonePassword,NewPassword,strlen(NewPassword));
  2274.  
  2275.                                 CloseSomeWindow(Context,Context->PasswordWindow);
  2276.                             }
  2277.  
  2278.                             break;
  2279.  
  2280.                             /* Close the editor window */
  2281.  
  2282.                         case GAD_CLOSE:
  2283.  
  2284.                             DetachList(Context);
  2285.                             UpdateEditorData(Context);
  2286.                             HighlightActiveEntry(Context,TRUE);
  2287.  
  2288.                             CloseSomeWindow(Context,Context->EditWindow);
  2289.                             break;
  2290.  
  2291.                             /* Hit the autodial button */
  2292.  
  2293.                         case GAD_MAIN_AUTODIAL:
  2294.  
  2295.                             LT_SetAttributes(Context->Manager,GAD_MAIN_EXIT_WHEN_FINISHED,
  2296.                                 GA_Disabled,    !Context->PhoneHandle->AutoDial,
  2297.                             TAG_DONE);
  2298.  
  2299.                             break;
  2300.  
  2301.                             /* Make a copy of the current entry */
  2302.  
  2303.                         case GAD_COPY:
  2304.  
  2305.                             CopyActiveEntry(Context);
  2306.                             break;
  2307.  
  2308.                             /* Delete the current entry */
  2309.  
  2310.                         case GAD_DELETE:
  2311.  
  2312.                             DeleteActiveEntry(Context);
  2313.                             break;
  2314.  
  2315.                             /* Load a new phonebook */
  2316.  
  2317.                         case GAD_LOAD:
  2318.  
  2319.                             LockInterface(Context);
  2320.  
  2321.                             LoadNewPhonebook(Context);
  2322.  
  2323.                             UnlockInterface(Context);
  2324.  
  2325.                             break;
  2326.  
  2327.                             /* Merge existing phonebook with a new phonebook loaded from disk */
  2328.  
  2329.                         case GAD_MERGE:
  2330.  
  2331.                             UpdateEditorData(Context);
  2332.  
  2333.                             LockInterface(Context);
  2334.  
  2335.                             MergeNewPhonebook(Context);
  2336.  
  2337.                             UnlockInterface(Context);
  2338.  
  2339.                             break;
  2340.  
  2341.                             /* Copy the selected group name into the text entry field */
  2342.  
  2343.                         case GAD_GROUP_LIST:
  2344.  
  2345.                             LT_SetAttributes(Context->Grouping,GAD_GROUP_NAME,
  2346.                                 GTST_String,Context->GroupLabels[MsgCode],
  2347.                             TAG_DONE);
  2348.  
  2349.                             break;
  2350.  
  2351.                             /* Do something to the selected entries. */
  2352.  
  2353.                         case GAD_GROUP_OK:
  2354.  
  2355.                             LockInterface(Context);
  2356.  
  2357.                             ChangeGroup(Context);
  2358.  
  2359.                             UnlockInterface(Context);
  2360.  
  2361.                             CloseSomeWindow(Context,Context->GroupWindow);
  2362.  
  2363.                             break;
  2364.  
  2365.                             /* Display a different group */
  2366.  
  2367.                         case GAD_GROUPID:
  2368.  
  2369.                             SelectGroup(Context,MsgCode);
  2370.                             break;
  2371.  
  2372.                             /* Get rid of this group */
  2373.  
  2374.                         case GAD_SPLIT_GROUP:
  2375.  
  2376.                             SplitGroup(Context);
  2377.                             break;
  2378.  
  2379.                             /* Sort the phonelist */
  2380.  
  2381.                         case GAD_SORT_AND_CLOSE:
  2382.                         case GAD_SORT_IT:
  2383.  
  2384.                             UpdateEditorData(Context);
  2385.  
  2386.                             if(Context->NumEntries > 1)
  2387.                             {
  2388.                                 LockInterface(Context);
  2389.  
  2390.                                 SortThePhonebook(Context,Criteria,ReverseOrder);
  2391.  
  2392.                                 UnlockInterface(Context);
  2393.                             }
  2394.  
  2395.                             if(MsgGadgetID != GAD_SORT_IT)
  2396.                                 CloseSomeWindow(Context,Context->SortWindow);
  2397.  
  2398.                             break;
  2399.  
  2400.                         case GAD_SORT_JUST_CLOSE:
  2401.  
  2402.                             CloseSomeWindow(Context,Context->SortWindow);
  2403.                             break;
  2404.  
  2405.                             /* Save the phonebook to disk */
  2406.  
  2407.                         case GAD_SAVE:
  2408.  
  2409.                             UpdateEditorData(Context);
  2410.  
  2411.                             if(Context->PhoneHandle->NumPhoneEntries > 0)
  2412.                             {
  2413.                                 UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  2414.                                 struct FileRequester *FileRequest;
  2415.  
  2416.                                 LockInterface(Context);
  2417.  
  2418.                                 strcpy(DummyBuffer,LastPhone);
  2419.  
  2420.                                 if(FileRequest = SaveFile(Context->Window,LocaleString(MSG_PHONEPANEL_SAVE_PHONEBOOK_TXT),NULL,"#?.prefs",DummyBuffer,sizeof(DummyBuffer)))
  2421.                                 {
  2422.                                     FreeAslRequest(FileRequest);
  2423.  
  2424.                                     if(!SavePhonebook(DummyBuffer,Context->PhoneHandle))
  2425.                                         ShowError(Context->Window,ERR_SAVE_ERROR,IoErr(),DummyBuffer);
  2426.                                     else
  2427.                                     {
  2428.                                         strcpy(LastPhone,DummyBuffer);
  2429.                                         strcpy(Config->PhonebookFileName,LastPhone);
  2430.  
  2431.                                         PhonebookChanged = FALSE;
  2432.                                     }
  2433.                                 }
  2434.  
  2435.                                 UnlockInterface(Context);
  2436.                             }
  2437.  
  2438.                             break;
  2439.  
  2440.                             /* Move to the first tagged entry */
  2441.  
  2442.                         case GAD_FIRST_ENTRY:
  2443.  
  2444.                             SelectNewTaggedEntry(Context,MOVE_HEAD);
  2445.                             break;
  2446.  
  2447.                             /* Move to the previous tagged entry */
  2448.  
  2449.                         case GAD_PREVIOUS_ENTRY:
  2450.  
  2451.                             SelectNewTaggedEntry(Context,MOVE_PRED);
  2452.                             break;
  2453.  
  2454.                             /* Move to the next tagged entry */
  2455.  
  2456.                         case GAD_NEXT_ENTRY:
  2457.  
  2458.                             SelectNewTaggedEntry(Context,MOVE_SUCC);
  2459.                             break;
  2460.  
  2461.                             /* Move to the next tagged entry */
  2462.  
  2463.                         case GAD_LAST_ENTRY:
  2464.  
  2465.                             SelectNewTaggedEntry(Context,MOVE_TAIL);
  2466.                             break;
  2467.  
  2468.                             /* Move entry to beginning of list */
  2469.  
  2470.                         case GAD_MOVE_FIRST:
  2471.  
  2472.                             MoveActiveEntry(Context,MOVE_HEAD);
  2473.                             break;
  2474.  
  2475.                             /* Move entry up in the list */
  2476.  
  2477.                         case GAD_MOVE_UP:
  2478.  
  2479.                             MoveActiveEntry(Context,MOVE_PRED);
  2480.                             break;
  2481.  
  2482.                             /* Move entry down in the list */
  2483.  
  2484.                         case GAD_MOVE_DOWN:
  2485.  
  2486.                             MoveActiveEntry(Context,MOVE_SUCC);
  2487.                             break;
  2488.  
  2489.                             /* Move entry to end of list */
  2490.  
  2491.                         case GAD_MOVE_LAST:
  2492.  
  2493.                             MoveActiveEntry(Context,MOVE_TAIL);
  2494.                             break;
  2495.  
  2496.                             /* Fiddle with the editor checkboxes */
  2497.  
  2498.                         case GAD_SERIAL_STATE:
  2499.                         case GAD_MODEM_STATE:
  2500.                         case GAD_SCREEN_STATE:
  2501.                         case GAD_TERMINAL_STATE:
  2502.                         case GAD_EMULATION_STATE:
  2503.                         case GAD_CLIPBOARD_STATE:
  2504.                         case GAD_CAPTURE_STATE:
  2505.                         case GAD_COMMAND_STATE:
  2506.                         case GAD_MISC_STATE:
  2507.                         case GAD_PATH_STATE:
  2508.                         case GAD_TRANSFER_STATE:
  2509.                         case GAD_TRANSLATION_STATE:
  2510.                         case GAD_MACRO_STATE:
  2511.                         case GAD_CURSOR_STATE:
  2512.                         case GAD_FASTMACRO_STATE:
  2513.                         case GAD_RATE_STATE:
  2514.  
  2515.                             if(Context->SelectedNode != NULL)
  2516.                             {
  2517.                                 if(ChangeState(MsgGadgetID,MsgCode,Context->SelectedNode))
  2518.                                 {
  2519.                                     HighlightActiveEntry(Context,FALSE);
  2520.  
  2521.                                     PhonebookChanged = TRUE;
  2522.                                 }
  2523.                             }
  2524.  
  2525.                             break;
  2526.  
  2527.                             /* Edit the settings of the current entry */
  2528.  
  2529.                         case GAD_SERIAL_EDIT:
  2530.                         case GAD_MODEM_EDIT:
  2531.                         case GAD_SCREEN_EDIT:
  2532.                         case GAD_TERMINAL_EDIT:
  2533.                         case GAD_EMULATION_EDIT:
  2534.                         case GAD_CLIPBOARD_EDIT:
  2535.                         case GAD_CAPTURE_EDIT:
  2536.                         case GAD_COMMAND_EDIT:
  2537.                         case GAD_MISC_EDIT:
  2538.                         case GAD_PATH_EDIT:
  2539.                         case GAD_TRANSFER_EDIT:
  2540.                         case GAD_TRANSLATION_EDIT:
  2541.                         case GAD_MACRO_EDIT:
  2542.                         case GAD_CURSOR_EDIT:
  2543.                         case GAD_FASTMACRO_EDIT:
  2544.                         case GAD_RATE_EDIT:
  2545.  
  2546.                             if(Context->SelectedNode)
  2547.                             {
  2548.                                 BOOL Result = FALSE;
  2549.  
  2550.                                 LockInterface(Context);
  2551.  
  2552.                                 if(MsgGadgetID == GAD_RATE_EDIT)
  2553.                                 {
  2554.                                     if(Context->SelectedNode->Entry == GetActiveEntry(Context->PhoneHandle))
  2555.                                         ShowRequest(Context->Window,LocaleString(MSG_PHONEPANEL_PHONE_ENTRY_IN_USE_EDIT_TXT),LocaleString(MSG_GLOBAL_CONTINUE_TXT));
  2556.                                     else
  2557.                                     {
  2558.                                         BOOL HadToFill = FALSE;
  2559.  
  2560.                                         if(IsListEmpty((struct List *)&Context->SelectedNode->Entry->TimeDateList))
  2561.                                         {
  2562.                                             struct TimeDateNode *TimeDateNode;
  2563.  
  2564.                                                 /* Provide defaults */
  2565.  
  2566.                                             if(TimeDateNode = CreateTimeDateNode(-1,-1,"",2))
  2567.                                             {
  2568.                                                 AddTail((struct List *)&Context->SelectedNode->Entry->TimeDateList,&TimeDateNode->Node);
  2569.  
  2570.                                                 HadToFill = TRUE;
  2571.  
  2572.                                                 Context->SelectedNode->Entry->Header->NoRates = FALSE;
  2573.                                             }
  2574.                                             else
  2575.                                                 Context->SelectedNode->Entry->Header->NoRates = TRUE;    /* Sorry, guv'nor */
  2576.                                         }
  2577.  
  2578.                                         if(!IsListEmpty((struct List *)&Context->SelectedNode->Entry->TimeDateList))
  2579.                                             Result = RatePanel(Context->EditWindow,Context->PhoneHandle,Context->SelectedNode->Entry,NULL);
  2580.                                         else
  2581.                                             Result = FALSE;
  2582.  
  2583.                                         if(!Result && HadToFill)
  2584.                                         {
  2585.                                                 /* Discard the time/date list */
  2586.  
  2587.                                             FreeTimeDateList((struct List *)&Context->SelectedNode->Entry->TimeDateList);
  2588.  
  2589.                                                 /* No rates here */
  2590.  
  2591.                                             Context->SelectedNode->Entry->Header->NoRates = TRUE;
  2592.                                         }
  2593.                                     }
  2594.                                 }
  2595.                                 else
  2596.                                     Result = EditConfig(Context->SelectedNode->Entry->Config,MsgGadgetID,MsgQualifier,Context->EditWindow);
  2597.  
  2598.                                 if(Result)
  2599.                                 {
  2600.                                     HighlightActiveEntry(Context,FALSE);
  2601.  
  2602.                                     PhonebookChanged = TRUE;
  2603.                                 }
  2604.  
  2605.                                 UnlockInterface(Context);
  2606.  
  2607.                                 LT_ShowWindow(Context->Editor,TRUE);
  2608.                             }
  2609.  
  2610.                             break;
  2611.  
  2612.                             /* Open the pattern selection window */
  2613.  
  2614.                         case GAD_PATTERN:
  2615.  
  2616.                             if(Context->PatternWindow)
  2617.                             {
  2618.                                 LT_ShowWindow(Context->Selector,TRUE);
  2619.                                 LT_Activate(Context->Selector,GAD_SELECT_NAME);
  2620.                             }
  2621.                             else
  2622.                             {
  2623.                                 if(Context->Selector = CreateSelectorHandle(Context->Window,NamePattern,NumberPattern,CommentPattern,&Mode))
  2624.                                     Context->PatternWindow = Context->Selector->Window;
  2625.                                 else
  2626.                                     DisplayBeep(Context->Window->WScreen);
  2627.                             }
  2628.  
  2629.                             break;
  2630.  
  2631.                             /* Apply the selection pattern to the phonebook */
  2632.  
  2633.                         case GAD_SELECT_APPLY:
  2634.                         case GAD_SELECT_APPLY_AND_CLOSE:
  2635.  
  2636.                             UpdateEditorData(Context);
  2637.  
  2638.                             LT_UpdateStrings(Context->Selector);
  2639.  
  2640.                             ParsePatternNoCase(NamePattern,        ParsedNamePattern,        130);
  2641.                             ParsePatternNoCase(NumberPattern,    ParsedNumberPattern,    130);
  2642.                             ParsePatternNoCase(CommentPattern,    ParsedCommentPattern,    130);
  2643.  
  2644.                             DetachList(Context);
  2645.  
  2646.                             for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  2647.                             {
  2648.                                 if((Node->Entry->Count < 0 && Mode != 0) || (Node->Entry->Count >= 0 && Mode == 0))
  2649.                                 {
  2650.                                     if(MatchPatternNoCase(ParsedNamePattern,Node->Entry->Header->Name) & MatchPatternNoCase(ParsedNumberPattern,Node->Entry->Header->Number) & MatchPatternNoCase(ParsedCommentPattern,Node->Entry->Header->Comment))
  2651.                                     {
  2652.                                         if(Mode)
  2653.                                             MarkDialEntry(Context->PhoneHandle,Node->Entry);
  2654.                                         else
  2655.                                             UnmarkDialEntry(Context->PhoneHandle,Node->Entry);
  2656.                                     }
  2657.                                 }
  2658.                             }
  2659.  
  2660.                             AttachList(Context);
  2661.  
  2662.                             UpdateWindowTitle(Context);
  2663.  
  2664.                             if(!Context->SelectedNode)
  2665.                             {
  2666.                                 LONG Index;
  2667.                                 BOOL GotIt;
  2668.  
  2669.                                 GotIt = FALSE;
  2670.  
  2671.                                 for(Index = 0, Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Index++, Node = (PhoneNode *)Node->Node.ln_Succ)
  2672.                                 {
  2673.                                     if(MatchPatternNoCase(ParsedNamePattern,Node->Entry->Header->Name) & MatchPatternNoCase(ParsedNumberPattern,Node->Entry->Header->Number) & MatchPatternNoCase(ParsedCommentPattern,Node->Entry->Header->Comment))
  2674.                                     {
  2675.                                         GotIt = TRUE;
  2676.                                         break;
  2677.                                     }
  2678.                                 }
  2679.  
  2680.                                 if(GotIt)
  2681.                                     SelectActiveEntry(Context,Index,TRUE);
  2682.                             }
  2683.  
  2684.                             HighlightActiveEntry(Context,FALSE);
  2685.  
  2686.                             if(MsgGadgetID != GAD_SELECT_APPLY)
  2687.                                 CloseSomeWindow(Context,Context->PatternWindow);
  2688.  
  2689.                             break;
  2690.  
  2691.                             /* Close the pattern window */
  2692.  
  2693.                         case GAD_SELECT_CLOSE:
  2694.  
  2695.                             CloseSomeWindow(Context,Context->PatternWindow);
  2696.                             break;
  2697.  
  2698.                             /* Dial the selected list */
  2699.  
  2700.                         case GAD_DIAL:
  2701.  
  2702.                             UpdateEditorData(Context);
  2703.  
  2704.                                 /* If no entry is tagged for dialing and we have */
  2705.                                 /* an active entry, tag it now. */
  2706.  
  2707.                             if(Context->PhoneHandle->DialMarker == 0 && Context->SelectedNode)
  2708.                                 MarkDialEntry(Context->PhoneHandle,Context->SelectedNode->Entry);
  2709.  
  2710.                                 /* Can we go and dial? */
  2711.  
  2712.                             if(Context->PhoneHandle->DialMarker > 0)
  2713.                             {
  2714.                                 DialTheList    = TRUE;
  2715.                                 Done        = TRUE;
  2716.                             }
  2717.  
  2718.                             break;
  2719.                     }
  2720.                 }
  2721.  
  2722.                     /* Double-clicked on an entry? */
  2723.  
  2724.                 if(MsgClass == IDCMP_IDCMPUPDATE && MsgGadgetID == GAD_NAMELIST)
  2725.                 {
  2726.                     if(!(MsgQualifier & SHIFT_KEY) && !Online && Context->PhoneHandle->Phonebook[MsgCode]->Header->Number[0])
  2727.                     {
  2728.                         PhoneEntry *Entry;
  2729.                         PhoneNode *Node;
  2730.  
  2731.                         UpdateEditorData(Context);
  2732.  
  2733.                         SelectActiveEntry(Context,MsgCode,FALSE);
  2734.  
  2735.                         DetachList(Context);
  2736.  
  2737.                         Entry = Context->SelectedNode->Entry;
  2738.  
  2739.                         for(Node = (PhoneNode *)Context->CurrentList->lh_Head ; Node->Node.ln_Succ ; Node = (PhoneNode *)Node->Node.ln_Succ)
  2740.                         {
  2741.                             if(Node->Entry == Entry)
  2742.                                 MarkDialEntry(Context->PhoneHandle,Node->Entry);
  2743.                             else
  2744.                                 UnmarkDialEntry(Context->PhoneHandle,Node->Entry);
  2745.                         }
  2746.  
  2747.                         UpdateWindowTitle(Context);
  2748.  
  2749.                         AttachList(Context);
  2750.  
  2751.                         HighlightActiveEntry(Context,FALSE);
  2752.  
  2753.                         if(Context->PhoneHandle->DialMarker > 0)
  2754.                         {
  2755.                             DialTheList    = TRUE;
  2756.                             Done        = TRUE;
  2757.                         }
  2758.  
  2759.                         LT_PressButton(Handle,GAD_DIAL);
  2760.                     }
  2761.                 }
  2762.             }
  2763.         }
  2764.         while(!Done);
  2765.  
  2766.         PopWindow();
  2767.     }
  2768.  
  2769.         /* Close the windows we have open */
  2770.  
  2771.     CloseSomeWindow(Context,Context->Window);
  2772.     CloseSomeWindow(Context,Context->EditWindow);
  2773.     CloseSomeWindow(Context,Context->PatternWindow);
  2774.     CloseSomeWindow(Context,Context->GroupWindow);
  2775.     CloseSomeWindow(Context,Context->SortWindow);
  2776.     CloseSomeWindow(Context,Context->PasswordWindow);
  2777.  
  2778.         /* Should we really go and dial the tagged entries? */
  2779.  
  2780.     if(DialTheList)
  2781.     {
  2782.             /* Remove all entries from the list. */
  2783.  
  2784.         DeleteDialList(Context->PhoneHandle);
  2785.  
  2786.             /* Add all the tagged phonebook entries to the dial list */
  2787.  
  2788.         if(!AddAllDialEntries(Context->PhoneHandle))
  2789.             DialTheList = FALSE;
  2790.     }
  2791.     else
  2792.     {
  2793.             /* Remove all entries from the list that got there during
  2794.              * the last dial attempt but are no longer tagged for
  2795.              * dialing.
  2796.              */
  2797.  
  2798.         CleanseDialList(Context->PhoneHandle);
  2799.     }
  2800.  
  2801.         /* If the phonebook has changed so will the dial menu */
  2802.  
  2803.     if(PhonebookChanged)
  2804.     {
  2805.         RebuildMenu = TRUE;
  2806.         ActivateJob(MainJobQueue,RebuildMenuJob);
  2807.     }
  2808.  
  2809.         /* If the phonebook needs rebuilding, start by
  2810.          * making the quick dial menu unavailable.
  2811.          */
  2812.  
  2813.     if(RebuildMenu)
  2814.         DisconnectDialMenu();
  2815.  
  2816.         /* Delete the display list */
  2817.  
  2818.     DeletePhoneList(Context->PhoneHandle);
  2819.  
  2820.         /* And delete the temporary data allocated */
  2821.  
  2822.     DeletePhoneListContext(Context);
  2823.  
  2824.     return(DialTheList);
  2825. }
  2826.